From d47e1a045e30c814421512834c02f93786ecdb6e Mon Sep 17 00:00:00 2001 From: Erik Alvarez Date: Mon, 29 Jun 2026 22:36:27 +0200 Subject: [PATCH 1/2] Rework notebooks 1.3 and 3.1; bump openTEPES to master tip 1.3 now follows the current openTEPES_run pipeline and writes into a work copy. 3.1 runs TSAM with the free HiGHS solver and writes the stage files into a work copy instead of the committed case. Gitlink bumped to master (086f13c0). Both added to the CI notebook run. --- .github/workflows/test-binder-environment.yml | 6 +- external/openTEPES | 2 +- .../1.3-openTEPES-Running-StepByStep.ipynb | 611 +- notebooks/3.1-LoadLevelAggregation_TSAM.ipynb | 142673 +-------------- 4 files changed, 747 insertions(+), 142545 deletions(-) diff --git a/.github/workflows/test-binder-environment.yml b/.github/workflows/test-binder-environment.yml index 1cb912a..65c907b 100644 --- a/.github/workflows/test-binder-environment.yml +++ b/.github/workflows/test-binder-environment.yml @@ -53,13 +53,15 @@ jobs: - name: Run the tutorial notebooks inside the built image run: | # Execute the notebooks in the built image so a notebook that no longer - # runs is caught. 1.3 and 3.1 are left out for now (3.1 writes back into - # the case folder and runs a clustering step); they need their own rework. + # runs is caught. Each notebook writes into a work_*/ copy of the case, + # so the committed cases are never changed. jupyter-repo2docker --image-name opentepes-tutorial:ci . \ bash -lc 'jupyter nbconvert --to notebook --execute \ --ExecutePreprocessor.timeout=900 --output-dir /tmp/executed \ notebooks/0*.ipynb \ + notebooks/1.3-openTEPES-Running-StepByStep.ipynb \ notebooks/2.1-Comparison.ipynb \ + notebooks/3.1-LoadLevelAggregation_TSAM.ipynb \ notebooks/4.*.ipynb \ notebooks/5.*.ipynb' diff --git a/external/openTEPES b/external/openTEPES index 1668d9d..086f13c 160000 --- a/external/openTEPES +++ b/external/openTEPES @@ -1 +1 @@ -Subproject commit 1668d9dd4504b5f788b0f9976e5b153149208375 +Subproject commit 086f13c088968fbc6d229bcb053f1ec9db0314e3 diff --git a/notebooks/1.3-openTEPES-Running-StepByStep.ipynb b/notebooks/1.3-openTEPES-Running-StepByStep.ipynb index 4868f4b..db058b6 100644 --- a/notebooks/1.3-openTEPES-Running-StepByStep.ipynb +++ b/notebooks/1.3-openTEPES-Running-StepByStep.ipynb @@ -2,387 +2,550 @@ "cells": [ { "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, + "id": "08e481b1", + "metadata": {}, "source": [ - "## 3. Running Step by Step\n", + "# Running openTEPES step by step\n", + "\n", + "`openTEPES_run` solves a case in a single call. Under the hood it is a short pipeline:\n", + "\n", + "1. **read** the input files,\n", + "2. **configure** the sets and parameters,\n", + "3. **set up** the decision variables,\n", + "4. **build** the objective function and the investment constraints,\n", + "5. **solve** the model, stage by stage,\n", + "6. **write** the results.\n", + "\n", + "This notebook runs that pipeline one call at a time, so you can stop after any step and inspect the model. It is the same sequence `openTEPES_run` uses, so nothing here is special to the tutorial.\n", "\n", - "In this running step by step, we will show how the ``openTEPES_run`` function works." + "We use the small **9n** case. To keep the run quick we work on a copy with a coarse time resolution and solve with the bundled HiGHS solver." ] }, { "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, + "id": "c115298d", + "metadata": {}, "source": [ - "#### Path and case study\n", - "In this tutorial the main scripts of the model are located in DIR and the case study will be the ``9n`` that is located in the folder with the same name.\n", - "In addition, we also declare the ``SolverName`` and ``IndLogConsole``.\n" + "## Make a fast working copy\n", + "\n", + "We never touch the committed `9n` folder. We copy it into `work_StepByStep/` and set a coarse `TimeStep` so the model is small and solves in a few seconds." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, + "id": "06b05fee", "metadata": { - "pycharm": { - "name": "#%%\n" + "execution": { + "iopub.execute_input": "2026-06-29T20:34:34.132559Z", + "iopub.status.busy": "2026-06-29T20:34:34.132187Z", + "iopub.status.idle": "2026-06-29T20:34:34.457099Z", + "shell.execute_reply": "2026-06-29T20:34:34.456741Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Working copy ready in work_StepByStep/9n\n" + ] + } + ], "source": [ - "DirName = ''\n", - "CaseName = '9n'\n", - "SolverName = 'glpk'\n", - "IndLogConsole = 'No'" + "import os, shutil, time\n", + "import pandas as pd\n", + "from pyomo.environ import ConcreteModel\n", + "\n", + "src, dst = \"9n\", \"work_StepByStep/9n\"\n", + "if os.path.exists(\"work_StepByStep\"):\n", + " shutil.rmtree(\"work_StepByStep\")\n", + "shutil.copytree(src, dst)\n", + "\n", + "par_file = os.path.join(dst, \"oT_Data_Parameter_9n.csv\")\n", + "par = pd.read_csv(par_file)\n", + "par.loc[:, \"TimeStep\"] = 24 # coarse resolution, just to keep this tutorial quick\n", + "par.to_csv(par_file, index=False)\n", + "print(\"Working copy ready in\", dst)" ] }, { "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, + "id": "47fd2195", + "metadata": {}, "source": [ - "#### Libraries\n", - "We start by importing the relevant libraries." + "## The pipeline functions\n", + "\n", + "`openTEPES_run` is assembled from functions that each live in their own module. We import the ones for the steps above." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, + "id": "680f9bc7", "metadata": { - "pycharm": { - "name": "#%%\n" + "execution": { + "iopub.execute_input": "2026-06-29T20:34:34.458149Z", + "iopub.status.busy": "2026-06-29T20:34:34.458079Z", + "iopub.status.idle": "2026-06-29T20:34:34.601213Z", + "shell.execute_reply": "2026-06-29T20:34:34.600782Z" } }, "outputs": [], "source": [ - "import time\n", - "import os\n", - "\n", - "from pyomo.environ import ConcreteModel, Set\n", - "from openTEPES import openTEPES as oT" + "from openTEPES.openTEPES_InputData import InputData\n", + "from openTEPES.openTEPES_DataConfiguration import DataConfiguration\n", + "from openTEPES.openTEPES_SettingUpVariables import SettingUpVariables\n", + "from openTEPES.openTEPES_ModelFormulationObjective import TotalObjectiveFunction\n", + "from openTEPES.openTEPES_ModelFormulationInvestment import InvestmentElecModelFormulation\n", + "from openTEPES.openTEPES_ProblemSolvingStageIter import StageIterativeSolving\n", + "from openTEPES.openTEPES_OutputResultsInvestment import InvestmentResults\n", + "from openTEPES.openTEPES_OutputResultsGeneration import GenerationOperationResults\n", + "from openTEPES.openTEPES_OutputResultsSummary import OperationSummaryResults" ] }, { "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, + "id": "1b709f6c", + "metadata": {}, "source": [ - "#### Data transforming\n", - "We start by importing the relevant libraries." + "Settings for the run. `pIndLogConsole = 0` keeps the solver log quiet; set it to `1` to see everything `openTEPES_run` would print." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, + "id": "3b86123f", "metadata": { - "pycharm": { - "name": "#%%\n" + "execution": { + "iopub.execute_input": "2026-06-29T20:34:34.602389Z", + "iopub.status.busy": "2026-06-29T20:34:34.602248Z", + "iopub.status.idle": "2026-06-29T20:34:34.604191Z", + "shell.execute_reply": "2026-06-29T20:34:34.603834Z" } }, "outputs": [], "source": [ - "InitialTime = time.time()\n", - "\n", - "idxDict = dict()\n", - "idxDict[0 ] = 0\n", - "idxDict[0.0 ] = 0\n", - "idxDict['No' ] = 0\n", - "idxDict['NO' ] = 0\n", - "idxDict['no' ] = 0\n", - "idxDict['N' ] = 0\n", - "idxDict['n' ] = 0\n", - "idxDict['Yes'] = 1\n", - "idxDict['YES'] = 1\n", - "idxDict['yes'] = 1\n", - "idxDict['Y' ] = 1\n", - "idxDict['y' ] = 1\n", + "DirName = \"work_StepByStep\"\n", + "CaseName = \"9n\"\n", + "SolverName = \"appsi_highs\"\n", + "pIndLogConsole = 0\n", "\n", - "pIndLogConsole = [j for i, j in idxDict.items() if i == IndLogConsole]" + "# the empty model object everything is attached to\n", + "mTEPES = ConcreteModel(\"openTEPES\")\n", + "mTEPES.pIndSectorDecomposition = 0 # solve the full problem, no sector decomposition" ] }, { "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, + "id": "b1af2682", + "metadata": {}, "source": [ - "#### Model object definition\n", - "We use the ``ConcreteModel`` function from pyomo to define our model, as follows:" + "## Step 1 — Read the input files\n", + "\n", + "`InputData` reads every `oT_Data_*.csv` in the case folder and returns the raw tables (`dfs`) and the parsed parameters (`par`)." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, + "id": "b15984af", "metadata": { - "pycharm": { - "name": "#%%\n" + "execution": { + "iopub.execute_input": "2026-06-29T20:34:34.605089Z", + "iopub.status.busy": "2026-06-29T20:34:34.605032Z", + "iopub.status.idle": "2026-06-29T20:34:34.749591Z", + "shell.execute_reply": "2026-06-29T20:34:34.749276Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input data ****\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading the CSV files ... 0 s\n", + "Reading input data ... 0 s\n", + "Input tables read: 29\n" + ] + } + ], "source": [ - "mTEPES = ConcreteModel('openTEPES')" + "dfs, par = InputData(DirName, CaseName, mTEPES, pIndLogConsole)\n", + "print(\"Input tables read:\", len(dfs))" ] }, { "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, + "id": "921331cf", + "metadata": {}, "source": [ - "#### Define sets and parameters" + "## Step 2 — Configure the sets and parameters\n", + "\n", + "`DataConfiguration` turns those tables into Pyomo sets (generators, nodes, lines, scenarios, periods, load levels, stages) and parameters on the model." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, + "id": "9158e4f6", "metadata": { - "pycharm": { - "name": "#%%\n" + "execution": { + "iopub.execute_input": "2026-06-29T20:34:34.750780Z", + "iopub.status.busy": "2026-06-29T20:34:34.750714Z", + "iopub.status.idle": "2026-06-29T20:34:35.269262Z", + "shell.execute_reply": "2026-06-29T20:34:35.268873Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setting up input data ... 1 s\n", + "generators : 16\n", + "nodes : 9\n", + "lines : 13\n", + "load levels: 364\n" + ] + } + ], "source": [ - "oT.InputData(DirName, CaseName, mTEPES, pIndLogConsole)" + "DataConfiguration(mTEPES, dfs, par)\n", + "print(\"generators :\", len(mTEPES.g))\n", + "print(\"nodes :\", len(mTEPES.nd))\n", + "print(\"lines :\", len(mTEPES.la))\n", + "print(\"load levels:\", len(mTEPES.n))" ] }, { "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, + "id": "d5509eb6", + "metadata": {}, "source": [ - "#### Define variables" + "## Step 3 — Set up the decision variables\n", + "\n", + "`SettingUpVariables` creates the variables: generator output, storage charge/discharge, line flows, investment decisions, and so on." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, + "id": "71f86c3b", "metadata": { - "pycharm": { - "name": "#%%\n" + "execution": { + "iopub.execute_input": "2026-06-29T20:34:35.270502Z", + "iopub.status.busy": "2026-06-29T20:34:35.270426Z", + "iopub.status.idle": "2026-06-29T20:34:35.422618Z", + "shell.execute_reply": "2026-06-29T20:34:35.422230Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setting up variables ... 0 s\n", + "variables built\n" + ] + } + ], "source": [ - "oT.SettingUpVariables(mTEPES, mTEPES)" + "SettingUpVariables(mTEPES, mTEPES)\n", + "print(\"variables built\")" ] }, { "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, + "id": "6b4c582a", + "metadata": {}, "source": [ - "#### Investment model objective function" + "## Step 4 — Build the objective and the investment constraints\n", + "\n", + "First we mark the first and last stage of the year (the solve walks the stages in order). Then `TotalObjectiveFunction` builds the cost objective, and `InvestmentElecModelFormulation` adds the investment constraints — but only if the case actually has something to invest in (candidate generators, storage, or lines)." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, + "id": "1d3092d1", "metadata": { - "pycharm": { - "name": "#%%\n" + "execution": { + "iopub.execute_input": "2026-06-29T20:34:35.423637Z", + "iopub.status.busy": "2026-06-29T20:34:35.423580Z", + "iopub.status.idle": "2026-06-29T20:34:35.426937Z", + "shell.execute_reply": "2026-06-29T20:34:35.426598Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total cost o.f. model formulation ****\n", + "Investment elec model formulation ****\n", + "candidate assets to invest in: 1\n" + ] + } + ], "source": [ - "oT.InvestmentModelFormulation(mTEPES, mTEPES, pIndLogConsole)" + "FirstST = 0\n", + "for st in mTEPES.st:\n", + " if FirstST == 0:\n", + " FirstST = 1\n", + " mTEPES.First_st = st\n", + " mTEPES.Last_st = st\n", + "\n", + "TotalObjectiveFunction(mTEPES, mTEPES, pIndLogConsole)\n", + "\n", + "has_candidates = len(mTEPES.gc) + len(mTEPES.gd) + len(mTEPES.lc) + len(mTEPES.rn) + len(mTEPES.pc) + len(mTEPES.hc)\n", + "if has_candidates:\n", + " InvestmentElecModelFormulation(mTEPES, mTEPES, pIndLogConsole)\n", + "\n", + "mTEPES.pDuals = {} # storage for the dual variables filled in during the solve\n", + "print(\"candidate assets to invest in:\", has_candidates)" ] }, { "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, + "id": "92186bf7", + "metadata": {}, "source": [ - "#### Iterative model formulation for each stage of a year\n", - "This part has two main sections: the first one active only scenario, period, and load levels to be used, and the second one, define the operation model objective function and constraints by stage." + "## Step 5 — Solve the model\n", + "\n", + "`StageIterativeSolving` builds the operation model for each stage and solves it. The operation constraints are added here, inside the solve, rather than all up front. This is the slow step; everything before it was just setup." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, + "id": "f86e3dab", "metadata": { - "pycharm": { - "name": "#%%\n" + "execution": { + "iopub.execute_input": "2026-06-29T20:34:35.427899Z", + "iopub.status.busy": "2026-06-29T20:34:35.427830Z", + "iopub.status.idle": "2026-06-29T20:34:39.322814Z", + "shell.execute_reply": "2026-06-29T20:34:39.322370Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Period 2030, Scenario sc01, Stage st1\n", + "Generation oper o.f. model formulation ****\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Investment & operation var constraints ****\n", + "Inertia, oper resr, demand constraints ****\n", + "Storage scheduling constraints ****\n", + "Unit commitment constraints ****\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ramp and min up/down time constraints ****\n", + "Network switching model constraints ****\n", + "Network operation model constraints ****\n", + "Problem solving #### 1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Termination condition: optimal\n", + " Total system cost [MEUR] 159.21117655177738 Constraints 41136 Variables 50966 Seconds 3\n", + "***** Period: 2030, Scenario: sc01, Stage: st1 ******\n", + " Total generation investment cost [MEUR] 0\n", + " Total generation retirement cost [MEUR] 0\n", + " Total reservoir investment cost [MEUR] 0.0\n", + " Total network investment cost [MEUR] 4.0412253282158845\n", + " Total H2 pipe investment cost [MEUR] 0.0\n", + " Total heat pipe investment cost [MEUR] 0.0\n", + " Total generation operation cost [MEUR] 155.1655062216117\n", + " Total consumption operation cost [MEUR] 0.002853297506587091\n", + " Total emission cost [MEUR] 0.0\n", + " Total network losses penalty cost [MEUR] 0.0015917044432770537\n", + " Total reliability electr cost [MEUR] 0.0\n", + "solved in 3.9 s\n" + ] + } + ], "source": [ - "for sc,p,st in mTEPES.scc*mTEPES.pp*mTEPES.stt:\n", - " # only scenario, period and load levels to formulate\n", - " mTEPES.del_component(mTEPES.sc)\n", - " mTEPES.del_component(mTEPES.p )\n", - " mTEPES.del_component(mTEPES.st)\n", - " mTEPES.del_component(mTEPES.n )\n", - " mTEPES.del_component(mTEPES.n2)\n", - " mTEPES.sc = Set(initialize=mTEPES.scc, ordered=True, doc='scenarios', filter=lambda mTEPES,scc: scc in mTEPES.scc and sc == scc and mTEPES.pScenProb [scc])\n", - " mTEPES.p = Set(initialize=mTEPES.pp, ordered=True, doc='periods', filter=lambda mTEPES,pp : pp in p == pp )\n", - " mTEPES.st = Set(initialize=mTEPES.stt, ordered=True, doc='stages', filter=lambda mTEPES,stt: stt in mTEPES.stt and st == stt and mTEPES.pStageWeight[stt] and sum(1 for (st, nn) in mTEPES.s2n))\n", - " mTEPES.n = Set(initialize=mTEPES.nn, ordered=True, doc='load levels', filter=lambda mTEPES,nn : nn in mTEPES.pDuration and (st,nn) in mTEPES.s2n)\n", - " mTEPES.n2 = Set(initialize=mTEPES.nn, ordered=True, doc='load levels', filter=lambda mTEPES,nn : nn in mTEPES.pDuration and (st,nn) in mTEPES.s2n)\n", + "_path = os.path.join(DirName, CaseName)\n", + "pIndCycleFlow = 0\n", "\n", - " # operation model objective function and constraints by stage\n", - " oT.GenerationOperationModelFormulation(mTEPES, mTEPES, pIndLogConsole, st)\n", - " oT.NetworkSwitchingModelFormulation (mTEPES, mTEPES, pIndLogConsole, st)\n", - " oT.NetworkOperationModelFormulation (mTEPES, mTEPES, pIndLogConsole, st)" + "t0 = time.time()\n", + "StageIterativeSolving(mTEPES, DirName, CaseName, SolverName, pIndLogConsole, _path, pIndCycleFlow)\n", + "print(f\"solved in {time.time() - t0:.1f} s\")" ] }, { "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, + "id": "8fd157d4", + "metadata": {}, "source": [ - "#### Create lp-format file\n", - "We save the LP-format file in the folder called ``9n``. " + "## Step 6 — Read the results\n", + "\n", + "The solved model carries the answer. The total system cost is the value of the objective expression." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, + "id": "43000ac2", "metadata": { - "pycharm": { - "name": "#%%\n" + "execution": { + "iopub.execute_input": "2026-06-29T20:34:39.323889Z", + "iopub.status.busy": "2026-06-29T20:34:39.323827Z", + "iopub.status.idle": "2026-06-29T20:34:39.325598Z", + "shell.execute_reply": "2026-06-29T20:34:39.325281Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total system cost: 159.211 MEUR\n" + ] + } + ], "source": [ - "StartTime = time.time()\n", - "mTEPES.write(CaseName+'/openTEPES_'+CaseName+'.lp', io_options={'symbolic_solver_labels': True})\n", - "WritingLPFileTime = time.time() - StartTime\n", - "StartTime = time.time()\n", - "print('Writing LP file ... ', round(WritingLPFileTime), 's')" + "total_cost = float(mTEPES.eTotalSCost.expr())\n", + "print(f\"Total system cost: {total_cost:.3f} MEUR\")" ] }, { "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, + "id": "8cbfd83c", + "metadata": {}, "source": [ - "#### Solving the mTEPES problem" + "To get the usual `oT_Result_*.csv` files, we call the result writers. We point them at the working folder and ask for CSV output (this is what `openTEPES_run` sets up for you)." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, + "id": "d260d76a", "metadata": { - "pycharm": { - "name": "#%%\n" + "execution": { + "iopub.execute_input": "2026-06-29T20:34:39.326543Z", + "iopub.status.busy": "2026-06-29T20:34:39.326492Z", + "iopub.status.idle": "2026-06-29T20:34:39.535064Z", + "shell.execute_reply": "2026-06-29T20:34:39.534636Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Writing investment results ... 0 s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Writing generation operation results ... 0 s\n", + "Writing KPI summary results ... 0 s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Writing elect network summary results ... 0 s\n", + "result files written to work_StepByStep/9n\n" + ] + } + ], "source": [ - "oT.ProblemSolving(DirName, CaseName, SolverName, mTEPES, mTEPES, pIndLogConsole)" + "mTEPES.pOutputPath = _path\n", + "mTEPES.pOutputBackend = \"csv\"\n", + "\n", + "# the three trailing numbers are: per-technology output, per-area output, plots\n", + "InvestmentResults (DirName, CaseName, mTEPES, mTEPES, 2, 1, 0)\n", + "GenerationOperationResults(DirName, CaseName, mTEPES, mTEPES, 2, 1, 0)\n", + "OperationSummaryResults (DirName, CaseName, mTEPES, mTEPES)\n", + "print(\"result files written to\", _path)" ] }, { "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, + "id": "3c77adee", + "metadata": {}, "source": [ - "#### Activating all possible scenario, period, and load levels" + "As a check, the total yearly energy produced by each technology:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, + "id": "524c07ea", "metadata": { - "pycharm": { - "name": "#%%\n" + "execution": { + "iopub.execute_input": "2026-06-29T20:34:39.536152Z", + "iopub.status.busy": "2026-06-29T20:34:39.536091Z", + "iopub.status.idle": "2026-06-29T20:34:39.539882Z", + "shell.execute_reply": "2026-06-29T20:34:39.539495Z" } }, - "outputs": [], - "source": [ - "mTEPES.del_component(mTEPES.sc)\n", - "mTEPES.del_component(mTEPES.p )\n", - "mTEPES.del_component(mTEPES.st)\n", - "mTEPES.del_component(mTEPES.n )\n", - "mTEPES.sc = Set(initialize=mTEPES.scc, ordered=True, doc='scenarios', filter=lambda mTEPES,scc: scc in mTEPES.scc and mTEPES.pScenProb [scc])\n", - "mTEPES.p = Set(initialize=mTEPES.pp, ordered=True, doc='periods', filter=lambda mTEPES,pp : pp in p == pp )\n", - "mTEPES.st = Set(initialize=mTEPES.stt, ordered=True, doc='stages', filter=lambda mTEPES,stt: stt in mTEPES.stt and mTEPES.pStageWeight[stt] and sum(1 for (stt, nn) in mTEPES.s2n))\n", - "mTEPES.n = Set(initialize=mTEPES.nn, ordered=True, doc='load levels', filter=lambda mTEPES,nn : nn in mTEPES.pDuration )\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" + "outputs": [ + { + "data": { + "text/plain": [ + "Coal 0.0\n", + "ESS 256.8\n", + "Gas 1258.0\n", + "Nuclear 6740.7\n", + "Oil 0.0\n", + "RES 1385.9\n", + "dtype: float64" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" } - }, + ], "source": [ - "#### Writing and plotting results" + "gen = pd.read_csv(os.path.join(_path, \"oT_Result_TechnologyGenerationEnergy_9n.csv\"))\n", + "tech = [c for c in gen.columns if c not in (\"Period\", \"Scenario\", \"LoadLevel\")]\n", + "gen[tech].sum().round(1)" ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], + "cell_type": "markdown", + "id": "4f12d987", + "metadata": {}, "source": [ - "oT.InvestmentResults (DirName, CaseName, mTEPES, mTEPES)\n", - "oT.GenerationOperationResults(DirName, CaseName, mTEPES, mTEPES)\n", - "oT.ESSOperationResults (DirName, CaseName, mTEPES, mTEPES)\n", - "oT.FlexibilityResults (DirName, CaseName, mTEPES, mTEPES)\n", - "oT.NetworkOperationResults (DirName, CaseName, mTEPES, mTEPES)\n", - "oT.MarginalResults (DirName, CaseName, mTEPES, mTEPES)\n", - "oT.EconomicResults (DirName, CaseName, mTEPES, mTEPES)\n", - "oT.NetworkMapResults (DirName, CaseName, mTEPES, mTEPES)\n", + "## What we just did\n", "\n", - "TotalTime = time.time() - InitialTime\n", - "print('Total time ... ', round(TotalTime), 's')" + "Reading, configuring, variable setup, objective and investment constraints, the stage-by-stage solve, and the result writers — run in that order — are exactly the pipeline inside `openTEPES_run`. Calling them one at a time lets you inspect `mTEPES` between steps, which is handy when you are debugging a case or learning how the model is built.\n", + "\n", + "In normal use you would just call `openTEPES_run(DirName, CaseName, SolverName, 'No', 'No')` and let it do all of this for you." ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -396,9 +559,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.5" + "version": "3.12.13" } }, "nbformat": 4, - "nbformat_minor": 1 -} \ No newline at end of file + "nbformat_minor": 5 +} diff --git a/notebooks/3.1-LoadLevelAggregation_TSAM.ipynb b/notebooks/3.1-LoadLevelAggregation_TSAM.ipynb index 997a2d3..fa261a0 100644 --- a/notebooks/3.1-LoadLevelAggregation_TSAM.ipynb +++ b/notebooks/3.1-LoadLevelAggregation_TSAM.ipynb @@ -2,96493 +2,88 @@ "cells": [ { "cell_type": "markdown", - "id": "183aacec", + "id": "54e161a4", "metadata": {}, "source": [ - "# Operation State Aggregation Per Days" - ] - }, - { - "cell_type": "markdown", - "id": "4f549e98", - "metadata": {}, - "source": [ - "## Data Transformation" - ] - }, - { - "cell_type": "markdown", - "id": "ede58676", - "metadata": {}, - "source": [ - "#### Importing libraries" - ] - }, - { - "cell_type": "code", - "execution_count": 421, - "id": "fbccc79d", - "metadata": {}, - "outputs": [], - "source": [ - "# libraries\n", - "import math\n", - "import copy\n", - "import os\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import tsam.timeseriesaggregation as tsam" + "# Time-series aggregation with TSAM\n", + "\n", + "A full year at hourly resolution is 8 760 time steps. For a large planning model that is expensive to solve. **Time-series aggregation** shrinks the year to a few *representative periods* — for example a handful of typical weeks — while keeping the shape of demand and renewable supply. openTEPES can then solve on those representative periods and weight each by how often it occurs.\n", + "\n", + "This notebook uses [TSAM](https://github.com/FZJ-IEK3-VSA/tsam) (the Time Series Aggregation Module) to turn the 9n year into **four typical weeks**, and writes the stage files openTEPES reads.\n", + "\n", + "The companion notebook [03-Stages](03-Stages.ipynb) shows how openTEPES uses such stage files once they exist." ] }, { "cell_type": "markdown", - "id": "31ce72e7", + "id": "30fd3a3f", "metadata": {}, "source": [ - "#### Setting up the path" - ] - }, - { - "cell_type": "code", - "execution_count": 422, - "id": "cb19a79f", - "metadata": {}, - "outputs": [], - "source": [ - "# DirName = os.getcwd()\n", - "DirName = ''\n", - "CaseName = '9n'\n", - "CasesToPaste = []\n", - "CasesToPaste.append(CaseName + '_ByStages')\n", + "## Make a working copy\n", "\n", - "for case in CasesToPaste:\n", - " _path = os.path.join(DirName, case)\n", - " if not os.path.exists(_path):\n", - " os.makedirs(_path)" + "We copy `9n` into `work_TSAM/` and write all aggregation outputs there, so the committed case is never changed." ] }, { "cell_type": "code", - "execution_count": 423, - "id": "76fabf42", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:5: DtypeWarning: Columns (3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86) have mixed types. Specify dtype option on import or set low_memory=False.\n", - " dict_Files[file] = pd.read_csv(os.path.join(DirName, CaseName, file), header=None)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:5: DtypeWarning: Columns (3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718) have mixed types. Specify dtype option on import or set low_memory=False.\n", - " dict_Files[file] = pd.read_csv(os.path.join(DirName, CaseName, file), header=None)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:5: DtypeWarning: Columns (3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718) have mixed types. Specify dtype option on import or set low_memory=False.\n", - " dict_Files[file] = pd.read_csv(os.path.join(DirName, CaseName, file), header=None)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:5: DtypeWarning: Columns (3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718) have mixed types. Specify dtype option on import or set low_memory=False.\n", - " dict_Files[file] = pd.read_csv(os.path.join(DirName, CaseName, file), header=None)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:5: DtypeWarning: Columns (3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718) have mixed types. Specify dtype option on import or set low_memory=False.\n", - " dict_Files[file] = pd.read_csv(os.path.join(DirName, CaseName, file), header=None)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:5: DtypeWarning: Columns (3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718) have mixed types. Specify dtype option on import or set low_memory=False.\n", - " dict_Files[file] = pd.read_csv(os.path.join(DirName, CaseName, file), header=None)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:5: DtypeWarning: Columns (3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718) have mixed types. Specify dtype option on import or set low_memory=False.\n", - " dict_Files[file] = pd.read_csv(os.path.join(DirName, CaseName, file), header=None)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:5: DtypeWarning: Columns (3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718) have mixed types. Specify dtype option on import or set low_memory=False.\n", - " dict_Files[file] = pd.read_csv(os.path.join(DirName, CaseName, file), header=None)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:5: DtypeWarning: Columns (3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718) have mixed types. Specify dtype option on import or set low_memory=False.\n", - " dict_Files[file] = pd.read_csv(os.path.join(DirName, CaseName, file), header=None)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:5: DtypeWarning: Columns (3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718) have mixed types. Specify dtype option on import or set low_memory=False.\n", - " dict_Files[file] = pd.read_csv(os.path.join(DirName, CaseName, file), header=None)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:5: DtypeWarning: Columns (3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718) have mixed types. Specify dtype option on import or set low_memory=False.\n", - " dict_Files[file] = pd.read_csv(os.path.join(DirName, CaseName, file), header=None)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:5: DtypeWarning: Columns (3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718) have mixed types. Specify dtype option on import or set low_memory=False.\n", - " dict_Files[file] = pd.read_csv(os.path.join(DirName, CaseName, file), header=None)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:5: DtypeWarning: Columns (3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718) have mixed types. Specify dtype option on import or set low_memory=False.\n", - " dict_Files[file] = pd.read_csv(os.path.join(DirName, CaseName, file), header=None)\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\4208040199.py:6: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " dict_Files[file].fillna(\"\", inplace=True)\n" - ] + "execution_count": 1, + "id": "61168578", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-29T20:33:37.683938Z", + "iopub.status.busy": "2026-06-29T20:33:37.683631Z", + "iopub.status.idle": "2026-06-29T20:33:40.618920Z", + "shell.execute_reply": "2026-06-29T20:33:40.618518Z" } - ], - "source": [ - "# reading all the csv files from Folder A, subfolder 1.Set and 2.Par and saving in a dictionary\n", - "dict_Files = {}\n", - "for file in os.listdir(os.path.join(DirName, CaseName)):\n", - " if file.endswith(\".csv\"):\n", - " dict_Files[file] = pd.read_csv(os.path.join(DirName, CaseName, file), header=None)\n", - " dict_Files[file].fillna(\"\", inplace=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 424, - "id": "c6f95e33", - "metadata": {}, + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Copying and pasting the file oT_Aggr_TypicalPeriods_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_Demand_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_Duration_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_Emission_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_EnergyInflows_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_EnergyOutflows_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_Generation_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_Inertia_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_Network_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_Network_TF2030_v3_org.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_NodeLocation_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_OperatingReserveDown_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_OperatingReserveUp_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_Option_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_Parameter_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_Period_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_Profiles_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_RESEnergy_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_ReserveMargin_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_Scenario_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_Stage_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_VariableEmissionCost_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_VariableFuelCost_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_VariableMaxConsumption_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_VariableMaxEnergy_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_VariableMaxGeneration_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_VariableMaxStorage_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_VariableMinConsumption_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_VariableMinEnergy_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_VariableMinGeneration_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Data_VariableMinStorage_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Dict_AreaToRegion_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Dict_Area_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Dict_Circuit_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Dict_Generation_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Dict_Line_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Dict_LoadLevel_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Dict_NodeToZone_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Dict_Node_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Dict_Period_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Dict_Region_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Dict_Scenario_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Dict_Stage_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Dict_Storage_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Dict_Technology_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Dict_ZoneToArea_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n", - "Copying and pasting the file oT_Dict_Zone_TF2030_v3.csv from TF2030_v3 to TF2030_v3_ByStages\n" + "Working copy ready in work_TSAM/9n\n" ] } ], "source": [ - "# saving the dataframes in the new folders with a new name\n", - "for case in CasesToPaste:\n", - " for file in dict_Files:\n", - " print('Copying and pasting the file ' + file + ' from ' + CaseName+ ' to ' + case)\n", - " dict_Files[file].fillna(\"\", inplace=True)\n", - " dict_Files[file].to_csv(os.path.join(DirName, case, file.split('_', 3)[0]+'_'+file.split('_', 3)[1]+'_'+file.split('_', 3)[2]+'_'+case+'.csv'), index=False, header=False)" - ] - }, - { - "cell_type": "markdown", - "id": "77487f45", - "metadata": {}, - "source": [ - "#### Loading data from CSV" - ] - }, - { - "cell_type": "code", - "execution_count": 425, - "id": "81936354", - "metadata": {}, - "outputs": [], - "source": [ - "dfProfiles = pd.read_csv(os.path.join(CaseName, 'oT_Data_Profiles_' + CaseName + '.csv'), index_col=[0,1,2])" - ] - }, - { - "cell_type": "markdown", - "id": "c82d793f", - "metadata": {}, - "source": [ - "#### Naming Indexes" - ] - }, - { - "cell_type": "code", - "execution_count": 426, - "id": "f4d81178", - "metadata": {}, - "outputs": [], - "source": [ - "dfProfiles.index.names = ['Period', 'Scenario', 'LoadLevel']" + "import os, shutil\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import tsam.timeseriesaggregation as tsam\n", + "\n", + "CaseName = \"9n\"\n", + "WORK = \"work_TSAM\"\n", + "if os.path.exists(WORK):\n", + " shutil.rmtree(WORK)\n", + "shutil.copytree(CaseName, os.path.join(WORK, CaseName))\n", + "CASE = os.path.join(WORK, CaseName)\n", + "print(\"Working copy ready in\", CASE)" ] }, { "cell_type": "markdown", - "id": "275645db", - "metadata": {}, - "source": [ - "#### Reset indexes and rename column of values" - ] - }, - { - "cell_type": "code", - "execution_count": 427, - "id": "f6eeae77", - "metadata": {}, - "outputs": [], - "source": [ - "dfProfiles = dfProfiles.reset_index()" - ] - }, - { - "cell_type": "code", - "execution_count": 428, - "id": "a5c3c3b0", - "metadata": {}, - "outputs": [], - "source": [ - "dfProfiles['Date'] = dfProfiles['LoadLevel']" - ] - }, - { - "cell_type": "code", - "execution_count": 429, - "id": "48341c25", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Timestamp('2030-01-01 00:00:00')" - ] - }, - "execution_count": 429, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pd.to_datetime('2030-'+dfProfiles['Date'][0][0:-6], errors='coerce')" - ] - }, - { - "cell_type": "code", - "execution_count": 430, - "id": "b83ea00a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'2030-01-01 00:00:00'" - ] - }, - "execution_count": 430, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "str(dfProfiles['Period'][0])+'-'+dfProfiles['Date'][0][:-6]" - ] - }, - { - "cell_type": "code", - "execution_count": 431, - "id": "afc7bc0f", + "id": "994f6421", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Timestamp('2030-01-01 00:00:00')" - ] - }, - "execution_count": 431, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "pd.to_datetime(str(dfProfiles['Period'][0])+'-'+dfProfiles['Date'][0][:-6], format='%Y-%m-%d %H:%M:%S')" + "## Load the profiles\n", + "\n", + "`oT_Data_Profiles` holds the hourly demand and renewable profiles. We build a proper datetime index from the period and the load-level timestamp so TSAM can split the series into periods." ] }, { "cell_type": "code", - "execution_count": 432, - "id": "6ced7f4b", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n", - "C:\\Users\\ealvarezq\\AppData\\Local\\Temp\\ipykernel_15836\\3279673283.py:3: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", - "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", - "A typical example is when you are setting values in a column of a DataFrame, like:\n", - "\n", - "df[\"col\"][row_indexer] = value\n", - "\n", - "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')\n" - ] + "execution_count": 2, + "id": "3fb15558", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-29T20:33:40.620106Z", + "iopub.status.busy": "2026-06-29T20:33:40.620005Z", + "iopub.status.idle": "2026-06-29T20:33:40.634277Z", + "shell.execute_reply": "2026-06-29T20:33:40.633915Z" } - ], - "source": [ - "dfProfiles['Date'] = dfProfiles['Date'].astype(str)\n", - "for i in range(len(dfProfiles)):\n", - " dfProfiles['Date'][i] = pd.to_datetime(str(dfProfiles['Period'][i])+'-'+dfProfiles['Date'][i][:-6], format='%Y-%m-%d %H:%M:%S')" - ] - }, - { - "cell_type": "code", - "execution_count": 433, - "id": "9b1b477e", - "metadata": {}, + }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\pandas\\core\\indexes\\base.py:7588: FutureWarning: Dtype inference on a pandas object (Series, Index, ExtensionArray) is deprecated. The Index constructor will keep the original dtype in the future. Call `infer_objects` on the result to get the old behavior.\n", - " return Index(sequences[0], name=names)\n" - ] - }, { "data": { "text/html": [ @@ -96510,9 +105,6 @@ " \n", " \n", " \n", - " Period\n", - " Scenario\n", - " LoadLevel\n", " Demand\n", " Solar\n", " Wind\n", @@ -96524,204 +116,155 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", " \n", " \n", " \n", " \n", " 2030-01-01 00:00:00\n", - " 2030\n", - " TF\n", - " 01-01 00:00:00+01:00\n", - " 449697.2520\n", - " 0.000096\n", - " 291276.9198\n", - " 34882.90352\n", + " 5360.331884\n", + " 0.57\n", + " 2131.9\n", + " 184.2\n", " \n", " \n", " 2030-01-01 01:00:00\n", - " 2030\n", - " TF\n", - " 01-01 01:00:00+01:00\n", - " 439171.2124\n", - " 0.000096\n", - " 282160.7195\n", - " 35205.78679\n", + " 5285.045823\n", + " 0.57\n", + " 2281.2\n", + " 199.0\n", " \n", " \n", " 2030-01-01 02:00:00\n", - " 2030\n", - " TF\n", - " 01-01 02:00:00+01:00\n", - " 422423.1437\n", - " 0.000096\n", - " 271495.5312\n", - " 35125.06598\n", + " 5272.172650\n", + " 0.57\n", + " 2114.6\n", + " 163.8\n", " \n", " \n", " 2030-01-01 03:00:00\n", - " 2030\n", - " TF\n", - " 01-01 03:00:00+01:00\n", - " 401038.1798\n", - " 0.000096\n", - " 262435.0828\n", - " 35006.07909\n", + " 5290.598321\n", + " 0.57\n", + " 2055.5\n", + " 167.8\n", " \n", " \n", " 2030-01-01 04:00:00\n", - " 2030\n", - " TF\n", - " 01-01 04:00:00+01:00\n", - " 390090.3895\n", - " 0.000096\n", - " 255248.7868\n", - " 34848.82612\n", - " \n", - " \n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " \n", - " \n", - " 2030-12-30 19:00:00\n", - " 2030\n", - " TF\n", - " 12-30 19:00:00+01:00\n", - " 603762.9529\n", - " 0.000096\n", - " 328144.4663\n", - " 32447.74233\n", - " \n", - " \n", - " 2030-12-30 20:00:00\n", - " 2030\n", - " TF\n", - " 12-30 20:00:00+01:00\n", - " 578764.8665\n", - " 0.000096\n", - " 322841.7538\n", - " 32248.03462\n", - " \n", - " \n", - " 2030-12-30 21:00:00\n", - " 2030\n", - " TF\n", - " 12-30 21:00:00+01:00\n", - " 548887.4174\n", - " 0.000096\n", - " 318170.6724\n", - " 32129.04773\n", - " \n", - " \n", - " 2030-12-30 22:00:00\n", - " 2030\n", - " TF\n", - " 12-30 22:00:00+01:00\n", - " 534121.7341\n", - " 0.000096\n", - " 314748.8096\n", - " 31967.60609\n", - " \n", - " \n", - " 2030-12-30 23:00:00\n", - " 2030\n", - " TF\n", - " 12-30 23:00:00+01:00\n", - " 505347.5141\n", - " 0.000096\n", - " 316126.6560\n", - " 31806.16446\n", + " 5429.858433\n", + " 0.57\n", + " 1998.6\n", + " 162.6\n", " \n", " \n", "\n", - "

8736 rows × 7 columns

\n", "" ], "text/plain": [ - " Period Scenario LoadLevel Demand \\\n", - "Date \n", - "2030-01-01 00:00:00 2030 TF 01-01 00:00:00+01:00 449697.2520 \n", - "2030-01-01 01:00:00 2030 TF 01-01 01:00:00+01:00 439171.2124 \n", - "2030-01-01 02:00:00 2030 TF 01-01 02:00:00+01:00 422423.1437 \n", - "2030-01-01 03:00:00 2030 TF 01-01 03:00:00+01:00 401038.1798 \n", - "2030-01-01 04:00:00 2030 TF 01-01 04:00:00+01:00 390090.3895 \n", - "... ... ... ... ... \n", - "2030-12-30 19:00:00 2030 TF 12-30 19:00:00+01:00 603762.9529 \n", - "2030-12-30 20:00:00 2030 TF 12-30 20:00:00+01:00 578764.8665 \n", - "2030-12-30 21:00:00 2030 TF 12-30 21:00:00+01:00 548887.4174 \n", - "2030-12-30 22:00:00 2030 TF 12-30 22:00:00+01:00 534121.7341 \n", - "2030-12-30 23:00:00 2030 TF 12-30 23:00:00+01:00 505347.5141 \n", - "\n", - " Solar Wind Hydro \n", - "Date \n", - "2030-01-01 00:00:00 0.000096 291276.9198 34882.90352 \n", - "2030-01-01 01:00:00 0.000096 282160.7195 35205.78679 \n", - "2030-01-01 02:00:00 0.000096 271495.5312 35125.06598 \n", - "2030-01-01 03:00:00 0.000096 262435.0828 35006.07909 \n", - "2030-01-01 04:00:00 0.000096 255248.7868 34848.82612 \n", - "... ... ... ... \n", - "2030-12-30 19:00:00 0.000096 328144.4663 32447.74233 \n", - "2030-12-30 20:00:00 0.000096 322841.7538 32248.03462 \n", - "2030-12-30 21:00:00 0.000096 318170.6724 32129.04773 \n", - "2030-12-30 22:00:00 0.000096 314748.8096 31967.60609 \n", - "2030-12-30 23:00:00 0.000096 316126.6560 31806.16446 \n", - "\n", - "[8736 rows x 7 columns]" + " Demand Solar Wind Hydro\n", + "Date \n", + "2030-01-01 00:00:00 5360.331884 0.57 2131.9 184.2\n", + "2030-01-01 01:00:00 5285.045823 0.57 2281.2 199.0\n", + "2030-01-01 02:00:00 5272.172650 0.57 2114.6 163.8\n", + "2030-01-01 03:00:00 5290.598321 0.57 2055.5 167.8\n", + "2030-01-01 04:00:00 5429.858433 0.57 1998.6 162.6" ] }, - "execution_count": 433, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "dfProfiles.set_index(['Date'])" + "prof = pd.read_csv(os.path.join(CASE, f\"oT_Data_Profiles_{CaseName}.csv\"), index_col=[0, 1, 2])\n", + "prof.index.names = [\"Period\", \"Scenario\", \"LoadLevel\"]\n", + "prof = prof.reset_index()\n", + "\n", + "# LoadLevel looks like '01-01 00:00:00+01:00'; drop the timezone tail and prepend the year\n", + "prof[\"Date\"] = pd.to_datetime(prof[\"Period\"].astype(str) + \"-\" + prof[\"LoadLevel\"].str[:-6],\n", + " format=\"%Y-%m-%d %H:%M:%S\")\n", + "profiles = prof.drop([\"Period\", \"Scenario\", \"LoadLevel\"], axis=1).set_index(\"Date\")\n", + "profiles.head()" ] }, { - "cell_type": "code", - "execution_count": 434, - "id": "4b726554", + "cell_type": "markdown", + "id": "dd8492da", "metadata": {}, - "outputs": [], "source": [ - "# remove the column LoadLevel\n", - "dfProfiles = dfProfiles.drop(['Scenario','Period','LoadLevel'], axis=1)" + "The full year, one line per series:" ] }, { "cell_type": "code", - "execution_count": 435, - "id": "f6f32e6f", - "metadata": {}, + "execution_count": 3, + "id": "95512caa", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-29T20:33:40.635277Z", + "iopub.status.busy": "2026-06-29T20:33:40.635221Z", + "iopub.status.idle": "2026-06-29T20:33:41.249537Z", + "shell.execute_reply": "2026-06-29T20:33:41.249097Z" + } + }, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\pandas\\core\\indexes\\base.py:7588: FutureWarning: Dtype inference on a pandas object (Series, Index, ExtensionArray) is deprecated. The Index constructor will keep the original dtype in the future. Call `infer_objects` on the result to get the old behavior.\n", - " return Index(sequences[0], name=names)\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "dfProfiles = dfProfiles.set_index(['Date'])" + "profiles.plot(subplots=True, figsize=(9, 6))\n", + "plt.tight_layout()\n", + "plt.show()" ] }, { - "cell_type": "code", - "execution_count": 436, - "id": "98e4a875", + "cell_type": "markdown", + "id": "75988d3c", "metadata": {}, + "source": [ + "## Aggregate to four typical weeks\n", + "\n", + "`TimeSeriesAggregation` clusters the 52 weeks of the year into a few representative ones. We ask for **4 typical weeks** (`hoursPerPeriod = 24*7`) with k-medoids clustering.\n", + "\n", + "`addPeakMin`/`addPeakMax` force the clustering to keep the periods that contain the extreme values (lowest renewable, highest demand), so the aggregated year does not lose the hard hours.\n", + "\n", + "The original version of this notebook used the commercial `gurobi` solver for the clustering. Here we use the free **`highs`** solver, the same one the rest of the tutorial uses, so it runs on Binder." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6cf1e4f4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-29T20:33:41.250823Z", + "iopub.status.busy": "2026-06-29T20:33:41.250733Z", + "iopub.status.idle": "2026-06-29T20:33:41.463282Z", + "shell.execute_reply": "2026-06-29T20:33:41.462912Z" + } + }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/sw/46j89ccx613gt8sh72tlvl1w0000gn/T/ipykernel_2213/4043587146.py:2: LegacyAPIWarning: TimeSeriesAggregation will be removed in tsam v4.0. Use tsam.aggregate() instead. See the migration guide in the documentation.\n", + " aggregation = tsam.TimeSeriesAggregation(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "typical periods shape: (672, 4) (4 weeks x 168 hours, 4 series)\n" + ] + }, { "data": { "text/html": [ @@ -96743,13 +286,15 @@ " \n", " \n", " \n", + " \n", " Demand\n", + " Hydro\n", " Solar\n", " Wind\n", - " Hydro\n", " \n", " \n", - " Date\n", + " \n", + " TimeStep\n", " \n", " \n", " \n", @@ -96758,420 +303,138 @@ " \n", " \n", " \n", - " 2030-01-01 00:00:00\n", - " 449697.2520\n", - " 0.000096\n", - " 291276.9198\n", - " 34882.90352\n", - " \n", - " \n", - " 2030-01-01 01:00:00\n", - " 439171.2124\n", - " 0.000096\n", - " 282160.7195\n", - " 35205.78679\n", - " \n", - " \n", - " 2030-01-01 02:00:00\n", - " 422423.1437\n", - " 0.000096\n", - " 271495.5312\n", - " 35125.06598\n", - " \n", - " \n", - " 2030-01-01 03:00:00\n", - " 401038.1798\n", - " 0.000096\n", - " 262435.0828\n", - " 35006.07909\n", - " \n", - " \n", - " 2030-01-01 04:00:00\n", - " 390090.3895\n", - " 0.000096\n", - " 255248.7868\n", - " 34848.82612\n", - " \n", - " \n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " \n", - " \n", - " 2030-12-30 19:00:00\n", - " 603762.9529\n", - " 0.000096\n", - " 328144.4663\n", - " 32447.74233\n", + " 0\n", + " 0\n", + " 5374.362506\n", + " 180.911168\n", + " 0.57\n", + " 2506.500000\n", " \n", " \n", - " 2030-12-30 20:00:00\n", - " 578764.8665\n", - " 0.000096\n", - " 322841.7538\n", - " 32248.03462\n", + " 1\n", + " 5297.312415\n", + " 195.270274\n", + " 0.57\n", + " 2506.500000\n", " \n", " \n", - " 2030-12-30 21:00:00\n", - " 548887.4174\n", - " 0.000096\n", - " 318170.6724\n", - " 32129.04773\n", + " 2\n", + " 5284.137610\n", + " 161.118887\n", + " 0.57\n", + " 2506.500000\n", " \n", " \n", - " 2030-12-30 22:00:00\n", - " 534121.7341\n", - " 0.000096\n", - " 314748.8096\n", - " 31967.60609\n", + " 3\n", + " 5302.995014\n", + " 164.999727\n", + " 0.57\n", + " 2506.500000\n", " \n", " \n", - " 2030-12-30 23:00:00\n", - " 505347.5141\n", - " 0.000096\n", - " 316126.6560\n", - " 31806.16446\n", + " 4\n", + " 5445.518133\n", + " 159.954635\n", + " 0.57\n", + " 2463.157424\n", " \n", " \n", "\n", - "

8736 rows × 4 columns

\n", "" ], "text/plain": [ - " Demand Solar Wind Hydro\n", - "Date \n", - "2030-01-01 00:00:00 449697.2520 0.000096 291276.9198 34882.90352\n", - "2030-01-01 01:00:00 439171.2124 0.000096 282160.7195 35205.78679\n", - "2030-01-01 02:00:00 422423.1437 0.000096 271495.5312 35125.06598\n", - "2030-01-01 03:00:00 401038.1798 0.000096 262435.0828 35006.07909\n", - "2030-01-01 04:00:00 390090.3895 0.000096 255248.7868 34848.82612\n", - "... ... ... ... ...\n", - "2030-12-30 19:00:00 603762.9529 0.000096 328144.4663 32447.74233\n", - "2030-12-30 20:00:00 578764.8665 0.000096 322841.7538 32248.03462\n", - "2030-12-30 21:00:00 548887.4174 0.000096 318170.6724 32129.04773\n", - "2030-12-30 22:00:00 534121.7341 0.000096 314748.8096 31967.60609\n", - "2030-12-30 23:00:00 505347.5141 0.000096 316126.6560 31806.16446\n", - "\n", - "[8736 rows x 4 columns]" + " Demand Hydro Solar Wind\n", + " TimeStep \n", + "0 0 5374.362506 180.911168 0.57 2506.500000\n", + " 1 5297.312415 195.270274 0.57 2506.500000\n", + " 2 5284.137610 161.118887 0.57 2506.500000\n", + " 3 5302.995014 164.999727 0.57 2506.500000\n", + " 4 5445.518133 159.954635 0.57 2463.157424" ] }, - "execution_count": 436, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "dfProfiles" + "HOURS = 24 * 7\n", + "aggregation = tsam.TimeSeriesAggregation(\n", + " profiles,\n", + " noTypicalPeriods=4,\n", + " hoursPerPeriod=HOURS,\n", + " clusterMethod=\"k_medoids\",\n", + " addPeakMin=[\"Hydro\", \"Solar\", \"Wind\"],\n", + " addPeakMax=[\"Demand\"],\n", + " solver=\"highs\",\n", + ")\n", + "typPeriods = aggregation.createTypicalPeriods()\n", + "print(\"typical periods shape:\", typPeriods.shape, \" (4 weeks x 168 hours, 4 series)\")\n", + "typPeriods.head()" ] }, { - "cell_type": "code", - "execution_count": 437, - "id": "c12ce361", + "cell_type": "markdown", + "id": "f1b16d94", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ - "axes = dfProfiles.plot(sharex = True, subplots = True)" + "Save the typical periods into the working case folder." ] }, { "cell_type": "code", - "execution_count": 438, - "id": "5caefca3", - "metadata": {}, - "outputs": [], - "source": [ - "def plotTS(data, periodlength, vmin, vmax):\n", - " fig, axes = plt.subplots(figsize = [6, 2], dpi = 100, nrows = 1, ncols = 1)\n", - " stacked, timeindex = tsam.unstackToPeriods(copy.deepcopy(data), periodlength)\n", - " cax = axes.imshow(stacked.values.T, interpolation = 'nearest', vmin = vmin, vmax = vmax)\n", - " axes.set_aspect('auto') \n", - " axes.set_ylabel('Hour')\n", - " plt.xlabel('Day')\n", - "\n", - " fig.subplots_adjust(right = 1.2)\n", - " cbar=plt.colorbar(cax) \n", - " cbar.set_label('Demand [MW]')" - ] - }, - { - "cell_type": "markdown", - "id": "628779d1", - "metadata": {}, - "source": [ - "## Aggregate the data\n", - "#### Initialize an aggregation to typical weeks." - ] - }, - { - "cell_type": "code", - "execution_count": 439, - "id": "6d710ba4", - "metadata": {}, - "outputs": [], - "source": [ - "aggregation = tsam.TimeSeriesAggregation(dfProfiles, noTypicalPeriods = 4, hoursPerPeriod = 24*7, \n", - " clusterMethod = 'k_medoids', \n", - " # extremePeriodMethod = 'append',\n", - " addPeakMin = ['Hydro','Solar','Wind'], addPeakMax = ['Demand'], solver='gurobi')" - ] - }, - { - "cell_type": "markdown", - "id": "5264ecbf", - "metadata": {}, - "source": [ - "#### Create the typical periods" - ] - }, - { - "cell_type": "code", - "execution_count": 440, - "id": "e75082fb", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\tsam\\timeseriesaggregation.py:873: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n", - "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n", - "\n", - "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n", - "\n", - "\n", - " typicalPeriods[column].clip(lower=0, upper=scale_ub, inplace=True)\n", - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\tsam\\timeseriesaggregation.py:875: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n", - "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n", - "\n", - "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n", - "\n", - "\n", - " typicalPeriods[column].fillna(0.0, inplace=True)\n", - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\tsam\\timeseriesaggregation.py:873: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n", - "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n", - "\n", - "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n", - "\n", - "\n", - " typicalPeriods[column].clip(lower=0, upper=scale_ub, inplace=True)\n", - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\tsam\\timeseriesaggregation.py:875: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n", - "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n", - "\n", - "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n", - "\n", - "\n", - " typicalPeriods[column].fillna(0.0, inplace=True)\n", - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\tsam\\timeseriesaggregation.py:873: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n", - "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n", - "\n", - "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n", - "\n", - "\n", - " typicalPeriods[column].clip(lower=0, upper=scale_ub, inplace=True)\n", - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\tsam\\timeseriesaggregation.py:875: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n", - "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n", - "\n", - "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n", - "\n", - "\n", - " typicalPeriods[column].fillna(0.0, inplace=True)\n", - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\tsam\\timeseriesaggregation.py:873: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n", - "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n", - "\n", - "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n", - "\n", - "\n", - " typicalPeriods[column].clip(lower=0, upper=scale_ub, inplace=True)\n", - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\tsam\\timeseriesaggregation.py:875: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n", - "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n", - "\n", - "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n", - "\n", - "\n", - " typicalPeriods[column].fillna(0.0, inplace=True)\n", - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\tsam\\timeseriesaggregation.py:873: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n", - "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n", - "\n", - "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n", - "\n", - "\n", - " typicalPeriods[column].clip(lower=0, upper=scale_ub, inplace=True)\n", - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\tsam\\timeseriesaggregation.py:875: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n", - "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n", - "\n", - "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n", - "\n", - "\n", - " typicalPeriods[column].fillna(0.0, inplace=True)\n", - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\tsam\\timeseriesaggregation.py:873: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n", - "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n", - "\n", - "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n", - "\n", - "\n", - " typicalPeriods[column].clip(lower=0, upper=scale_ub, inplace=True)\n", - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\tsam\\timeseriesaggregation.py:875: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n", - "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n", - "\n", - "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n", - "\n", - "\n", - " typicalPeriods[column].fillna(0.0, inplace=True)\n", - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\tsam\\timeseriesaggregation.py:873: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n", - "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n", - "\n", - "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n", - "\n", - "\n", - " typicalPeriods[column].clip(lower=0, upper=scale_ub, inplace=True)\n", - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\tsam\\timeseriesaggregation.py:875: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n", - "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n", - "\n", - "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n", - "\n", - "\n", - " typicalPeriods[column].fillna(0.0, inplace=True)\n" - ] + "execution_count": 5, + "id": "e827d4ce", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-29T20:33:41.464420Z", + "iopub.status.busy": "2026-06-29T20:33:41.464263Z", + "iopub.status.idle": "2026-06-29T20:33:41.468111Z", + "shell.execute_reply": "2026-06-29T20:33:41.467863Z" } - ], - "source": [ - "typPeriods = aggregation.createTypicalPeriods()" - ] - }, - { - "cell_type": "code", - "execution_count": 441, - "id": "02e8cb54", - "metadata": {}, - "outputs": [], - "source": [ - "typPeriods.to_csv(CaseName+'/oT_Aggr_TypicalPeriods_' +CaseName+'.csv')" - ] - }, - { - "cell_type": "code", - "execution_count": 442, - "id": "d57e2663", - "metadata": {}, + }, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\tsam\\timeseriesaggregation.py:1240: FutureWarning: The previous implementation of stack is deprecated and will be removed in a future version of pandas. See the What's New notes for pandas 2.1.0 for details. Specify future_stack=True to adopt the new implementation and silence this warning.\n", - " clustered_data_df = clustered_data_df.stack(level=\"TimeStep\")\n" + "written: oT_Aggr_TypicalPeriods_9n.csv\n" ] } ], "source": [ - "predictedPeriods = aggregation.predictOriginalData()" - ] - }, - { - "cell_type": "code", - "execution_count": 443, - "id": "53f0760e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsEAAADbCAYAAACMY0ygAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABDeUlEQVR4nO3dfVxUZfo/8M+ZgRmQhRFSHkZRWVM3hdzSUrRCNEFXslZ3qyURsuVroZmhWdqvFV3TMiVXtGcTTV3ru0nbw+aCz8saaqTfRF21DRUTJA0BEYZh5v79MXByYGYcZsYZdD7v1+u8cs655sw997nWveb2PveRhBACREREREReROHpBhARERERuRuLYCIiIiLyOiyCiYiIiMjrsAgmIiIiIq/DIpiIiIiIvA6LYCIiIiLyOiyCiYiIiMjrsAgmIiIiIq/DIpiIiIiIvA6LYCIiIiLyOj6eboA93njjDbz22msoLy/HgAEDsGLFCtx77712vddoNOLcuXMIDAyEJEnXuaVERETUEQkhUFtbC61WC4XCM2OADQ0NaGxstHpcpVLBz8/PjS3ybh2+CP7www8xc+ZMvPHGGxg+fDjefvttjB07FkePHkWPHj2u+f5z584hMjLSDS0lIiKijq6srAzdu3d3++c2NDQgqucvUFFpsBoTHh6O0tJSFsJuIgkhhKcbYcuQIUNw55134s0335T33XbbbXjooYewZMmSa76/uroanTt3Rv9JL0Gp8oNkvOqgEVDVmnYIHwkNwQoomkzdYSlO+JhGkp2Ka/6vM3GtP9ORuIZg069gZ+Ja952n4mxdC1fHMQds952n4pgDjsUxBxyLYw7Y7jtPxV3r2jYJHQ59sgiXLl2CRqOBu9XU1ECj0eC7ryMRFNh2JLqm1ohbB5ehuroaQUFBbm+fN+rQI8GNjY0oLi7GCy+8YLY/ISEBe/futfgenU4HnU4nv66trQUAKFV+FotgH1/TDqOPBKVKAYXC8v+IfHyNMDb/xeJUXPN/nYmz9BdVe+OUqua/WJyIa913noqzdS1cHcccsN13nopjDjgWxxxwLI45YLvvPBV3rWsrhKlfPD01slOgQKfAtuOPTejQY5I3pQ59Y9yFCxdgMBgQFhZmtj8sLAwVFRUW37NkyRJoNBp541QIIiIi6ij0wmh1I/fq0EVwi9a/2oQQVn/JzZ07F9XV1fJWVlbmjiYSERERXZMRAgYLm5EjwW7XoadDdOnSBUqlss2ob2VlZZvR4RZqtRpqtdodzSMiIiJqF9Oor+X95F4dughWqVQYNGgQCgoK8Nvf/lbeX1BQgAcffLBd51I2AEqjaa6QJH6eN+R7xZR0Tf4KKBsEFE2Qj7WOa/JXNJ/L8biWuUrOxLUccyZO2WBqszNxrfvOkThb18LeOFvXwtVxzAH7r629ccwB5gBzgDngjhww+HSMkVY9BPQWRn0t7bOlV69eOH36dJv9GRkZWL16NYQQWLBgAd555x1UVVVhyJAhWL16NQYMGCDH6nQ6zJ49G3/9619RX1+PUaNG4Y033jBbPaOqqgozZszAp59+CgAYP348cnJy0LlzZznmzJkzmDZtGnbs2AF/f38kJydj2bJlUKlUcszhw4cxffp07N+/HyEhIZg6dSpeeuklj87R7vDTITIzM/Hee+/h/fffx7Fjx/Dss8/izJkzePLJJz3dNCIiIqJ2MQjrW3scOHAA5eXl8lZQUAAA+P3vfw8AWLp0KbKzs7Fq1SocOHAA4eHhGD16tLxgAADMnDkTeXl52Lx5MwoLC3H58mUkJSXBYPh5Gbfk5GQcOnQIW7duxdatW3Ho0CGkpKT8/H0MBowbNw51dXUoLCzE5s2b8fHHH2PWrFlyTE1NDUaPHg2tVosDBw4gJycHy5YtQ3Z2tiNd6DIdeiQYAB555BFcvHgRCxcuRHl5OaKjo/GPf/wDPXv29HTTiIiIiNqlCRL0aDv62WRhny1du3Y1e/3KK6+gd+/eiIuLgxACK1aswIsvvogJEyYAANatW4ewsDBs2rQJU6dORXV1NdasWYMPPvgA999/PwBgw4YNiIyMxLZt25CYmIhjx45h69atKCoqwpAhQwAA7777LmJjY3H8+HH069cP+fn5OHr0KMrKyqDVagEAy5cvR1paGl5++WUEBQVh48aNaGhoQG5uLtRqNaKjo3HixAlkZ2cjMzPTY6PBHX4kGDAN7Z86dQo6nQ7FxcW47777PN0kIiIionbTC8nqBphGTa/erl721ZrGxkZs2LABU6ZMgSRJKC0tRUVFBRISEuQYtVqNuLg4eYnZ4uJi6PV6sxitVovo6Gg55quvvoJGo5ELYAAYOnQoNBqNWUx0dLRcAANAYmKiXLO1xMTFxZnds5WYmIhz587h1KlT7e1Cl7khimAiIiKim4EBktUNACIjI82WerXnwWCffPIJLl26hLS0NACQFxSwtcRsRUUFVCoVgoODbcaEhoa2+bzQ0FCzmNafExwcDJVKZTOm5bW1JW/docNPhyAiIiK6WeiFAnrRdgyyZcWIsrIysyfG2bPi1Zo1azB27Fiz0VgA7Vpi1lqMpXhXxLQ8sJg3xhERERF5gSahhN7C1iSUAICgoCCz7VpF8OnTp7Ft2zb88Y9/lPeFh4cDaDvKevUSs+Hh4WhsbERVVZXNmPPnz7f5zB9//NEspvXnVFVVQa/X24yprKwE0Ha02p28ZiRYqRdQQkASPy/bomgSUDaYXhh9JCj1gKL5p5ilOPlRlE7EtTzb3Jk4qfnXojNxSn1zm52Ia913jsTZuhb2xtm6Fq6OYw7Yf23tjWMOMAeYA8wBd+SAQt0xlki7eupD6/2OWLt2LUJDQzFu3Dh5X1RUFMLDw1FQUIA77rgDgGne8O7du/Hqq68CAAYNGgRfX18UFBTg4YcfBgCUl5ejpKQES5cuBQDExsaiuroa+/fvx9133w0A2LdvH6qrqzFs2DA55uWXX0Z5eTkiIiIAAPn5+VCr1Rg0aJAcM2/ePDQ2NsrLpuXn50Or1aJXr14OfW9X4EgwERERkZuYRn59LGzKdp/LaDRi7dq1SE1NhY/Pz+OakiRh5syZWLx4MfLy8lBSUoK0tDR06tQJycnJAACNRoMnnngCs2bNwvbt23Hw4EFMmjQJMTEx8moRt912G8aMGYP09HQUFRWhqKgI6enpSEpKQr9+/QAACQkJ6N+/P1JSUnDw4EFs374ds2fPRnp6ujytIzk5GWq1GmlpaSgpKUFeXh4WL17s0ZUhAC8aCSYiIiLytEahhK+FgrfRgYHqbdu24cyZM5gyZUqbY3PmzEF9fT0yMjLkh2Xk5+cjMDBQjnn99dfh4+ODhx9+WH5YRm5uLpTKn9u3ceNGzJgxQ15FYvz48Vi1apV8XKlU4osvvkBGRgaGDx9u9rCMFhqNBgUFBZg2bRoGDx6M4OBgZGZmIjMzs/1f2oVYBBMRERG5iRESjBamPljady0JCQnyDWatSZKErKwsZGVlWX2/n58fcnJykJOTYzUmJCQEGzZssNmOHj164PPPP7cZExMTgz179tiMcTcWwURERERuohc+aLQwEtyyTjC5D4tgIiIiIjdpWQ2i7X4PNMbLeU0RLBkAhQKAEFA0PxJbqTNC0WS6a1QyKgEB+ZilOMnYnLROxCl1zXepOhPX/E8fTsU1/4/NmbjWfedInK1rYW+crWvh6jjmAHOAOcAcYA7coDngiw7BAAUMFtYlMLR8WXIbrymCiYiIiDzN2koQnA7hfiyCiYiIiNykCQqLRXATR4LdjkUwERERkZsYhAIGC49NtrSPri8WwURERERuohdK+FicDsGRYHdjEUxERETkJiyCOw4WwURERERuYrSyOoTRwj66vrymCBZKwKgEJKP089NVBADTyikw+koQClMMYDnO6Gu6c9OpuJYfek7EScbm107EtUw9ciquVd85EmfrWtgbZ+tauDqOOcAcYA4wB5gDN24OdAR6oYSSI8EdgtcUwURERESephcKK0Ww0QOt8W4sgomIiIjcxCgUMFpYCcLSPrq+WAQTERERuUmTlccmN3EkuI2QkJB2xUuShG+++QY9e/a0K55FMBEREZGb6I1KKIwWpkMYWQS3dunSJaxYsQIajeaasUIIZGRkwGAwXDO2RYcugrOysrBgwQKzfWFhYaioqPBQi4iIiIgcZ7CyOoSlfQQ8+uijCA0NtSv26aefbte5O3QRDAADBgzAtm3b5NdKZdtfT/Zo/IUEpUqCZAQkg+kOUWXDz3diNmgUaAqQYGg0vbYU16AxJagzca0/05E4qfnHojNxTQGmNns6zta1sDfO1rVwdRxzwPVxzAHmAHOAOeCOHNAFdYwis8nK6hCcDtGWsZ2j47W1te2K7/BFsI+PD8LDwz3dDCIiIiKn6Y0KKIxtC3K9hX0EXLlyBZ06dbou5+7wPX7y5ElotVpERUXh0Ucfxffff28zXqfToaamxmwjIiIi6ghE8+oQrTfB1SEs6ty5M+6991786U9/ws6dO6HT6Vx27g7d40OGDMH69evxz3/+E++++y4qKiowbNgwXLx40ep7lixZAo1GI2+RkZFubDERERGRdXohQS8UFraO8TCPjmbNmjXo168fNm3ahFGjRiE4OBgjR47En//8ZxQWFkKv1zt87g5dBI8dOxYTJ05ETEwM7r//fnzxxRcAgHXr1ll9z9y5c1FdXS1vZWVl7mouERERkU1NQml1o7ZSUlLw3nvv4bvvvsOZM2fw1ltvISoqCmvXrkVcXByCg4ORmJjo0Lk7/JzgqwUEBCAmJgYnT560GqNWq6FWq93YKiIiIiL7GIQEg4VRX0v7yFz37t0xefJkTJ48GSdPnsT69euxcuVKswUU2uOGKoJ1Oh2OHTuGe++9t93vvdwTUPgBEIDPFVOiqWslNOlNv7yq+wBGlREKfXMSWoir7mM65Eycutb02qm45ptdnYkzqkx3XDoT17rvHImzdS3sjbN1LVwdxxyw/9raG8cccDCOOeDya2tvHHPA/mtrb5w7cqCmt/3rx15PTcLyOsEcCbbt+++/x86dO7Fr1y7s2rUL1dXVGDZsGJ5//nnExcU5dM4OXQTPnj0bDzzwAHr06IHKykosWrQINTU1SE1N9XTTiIiIiNrNIBRosnATnIE3xlmUmpqKnTt3ora2FsOHD8d9992H6dOnY/DgwQ4vm9uiQxfBZ8+exR/+8AdcuHABXbt2xdChQ1FUVGT34/CIiIiIOpKW1SAs7ae2PvjgA/To0QPz5s3DqFGjcMcdd0CSXDN1pEMXwZs3b/Z0E4iIiIhcpkkoIFkoeC2NDhNw9OhReQpEdnY2GhoacM899yAuLg4jRozAnXfeCYXCsb7r0EUwERER0c2kyaiAZOHBGE18WIZFv/rVr/CrX/0KTz75JABTUbx7927s3LkTy5cvR319Pe655x58/vnn7T43i2AiIiIiNzEKCUYLK0FY2kdt9e/fHyEhIQgODkZwcDA2b96ML7/80qFzsQgmIiIichODkCxOh+ASadZVVlZi165d8uoQJ06cgEqlwt13341nn30W8fHxDp3Xa4pgfVc9FP6muwibrpj+23hWAYXetIaLPqIRklLAoP85MVvH6SMaAcCpuMazpteejpOUpu/tTFzrvnMkzta1sDfO1rVwdRxzwDyOOcAcYA4wB26YHAivR0fQZFQALpoO8cMPP+D555/Hl19+ifr6evTt2xdr1qzBoEGDAABCCCxYsADvvPMOqqqqMGTIEKxevRoDBgyQz6HT6TB79mz89a9/RX19PUaNGoU33ngD3bt3l2OqqqowY8YMfPrppwCA8ePHIycnB507d5Zjzpw5g2nTpmHHjh3w9/dHcnIyli1bBpVKJcccPnwY06dPx/79+xESEoKpU6fipZdesnmjW//+/XH8+HH4+PjgrrvuwsSJExEfH4/hw4fDz8+v3X12Na8pgomIiIg8zVXTIaqqqjB8+HDEx8fjyy+/RGhoKP773/+aFaZLly5FdnY2cnNz0bdvXyxatAijR4/G8ePHERgYCACYOXMmPvvsM2zevBm33HILZs2ahaSkJBQXF8tLkCUnJ+Ps2bPYunUrAOB//ud/kJKSgs8++wwAYDAYMG7cOHTt2hWFhYW4ePEiUlNTIYRATk4OAKCmpgajR49GfHw8Dhw4gBMnTiAtLQ0BAQGYNWuW1e/54IMPIj4+Hvfccw86derUrj66FhbBRERERG5isHJjnKGdI8GvvvoqIiMjsXbtWnlfr1695D8LIbBixQq8+OKLmDBhAgBg3bp1CAsLw6ZNmzB16lRUV1djzZo1+OCDD3D//fcDADZs2IDIyEhs27YNiYmJOHbsGLZu3YqioiIMGTIEAPDuu+8iNjYWx48fR79+/ZCfn4+jR4+irKwMWq0WALB8+XKkpaXh5ZdfRlBQEDZu3IiGhgbk5uZCrVYjOjoaJ06cQHZ2NjIzM62OBi9ZsqRd/dIeLIKJiIiI3KRJKAAbS6TV1NSY7Ver1VCr1W3iP/30UyQmJuL3v/89du/ejW7duiEjIwPp6ekAgNLSUlRUVCAhIcHsXHFxcdi7dy+mTp2K4uJi6PV6sxitVovo6Gjs3bsXiYmJ+Oqrr6DRaOQCGACGDh0KjUaDvXv3ol+/fvjqq68QHR0tF8AAkJiYCJ1Oh+LiYsTHx+Orr75CXFyc2XdJTEzE3LlzcerUKURFRVnsr4ULF9rszxZ/+tOf7Iq7GotgIiIiIjcRQoKwMPWhZV9kZKTZ/vnz5yMrK6tN/Pfff48333wTmZmZmDdvHvbv348ZM2ZArVZj8uTJqKioAACEhYWZvS8sLAynT58GAFRUVEClUiE4OLhNTMv7KyoqEBoa2ubzQ0NDzWJaf05wcDBUKpVZzNUj1Ve3raKiwmoRnJWVBa1Wi9DQUAghLMZIksQimIiIiKgju9Z0iLKyMgQFBcn7LY0CA4DRaMTgwYOxePFiAMAdd9yBI0eO4M0338TkyZPluNbTDIQQ13ziWusYS/GuiGkpam21Z8yYMdi5cycGDx6MKVOmYNy4cU4/LrmF1xTBnTo3QNlJQAigQW26U1Gn8YdkMHVkUHAtjFf9OrMUFxRcCwBOxek0/gDgVFzLDyFn4ozy5zke17rvHImzdS3sjbN1LVwdxxxgDjAHmAPMgRszBwI7d4zVIYxCgsFo/ca4oKAgsyLYmoiICPTv399s32233YaPP/4YABAeHg7ANMoaEREhx1RWVsojsOHh4WhsbERVVZXZaHBlZSWGDRsmx5w/f77N5//4449m59m3b5/Z8aqqKuj1erOYllHhqz8HaDtafbV//OMfKC8vR25uLp577jlMnToVkydPxpQpU9CvXz+r77MHH09CRERE5CZGSFa39hg+fDiOHz9utu/EiRPo2bMnACAqKgrh4eEoKCiQjzc2NmL37t1ygTto0CD4+vqaxZSXl6OkpESOiY2NRXV1Nfbv3y/H7Nu3D9XV1WYxJSUlKC8vl2Py8/OhVqvl5dpiY2OxZ88eNDY2msVotdo20yRai4iIwNy5c3H8+HF8+OGHqKysxF133YXhw4ejvt7xHzcsgomIiIjcxGBUWN3a49lnn0VRUREWL16M7777Dps2bcI777yDadOmATBNMZg5cyYWL16MvLw8lJSUIC0tDZ06dUJycjIAQKPR4IknnsCsWbOwfft2HDx4EJMmTUJMTIy8WsRtt92GMWPGID09HUVFRSgqKkJ6ejqSkpLkkdiEhAT0798fKSkpOHjwILZv347Zs2cjPT1dHtVOTk6GWq1GWloaSkpKkJeXh8WLF9tcGcKSu+66C/Hx8bjttttw8OBB6PX6dvXb1bxmOgQRERGRpxmNEiRL0yEs7LPlrrvuQl5eHubOnYuFCxciKioKK1aswGOPPSbHzJkzB/X19cjIyJAflpGfny+vEQwAr7/+Onx8fPDwww/LD8vIzc01m3e7ceNGzJgxQ15FYvz48Vi1apV8XKlU4osvvkBGRgaGDx9u9rCMFhqNBgUFBZg2bRoGDx6M4OBgZGZmIjMz067v+9VXX+H999/HRx99hL59++Lxxx9HcnKyXVNHrGERTEREROQm11odoj2SkpKQlJRk9bgkScjKyrK4ukQLPz8/5OTkyA+1sCQkJAQbNmyw2ZYePXrg888/txkTExODPXv22IxpbenSpVi7di0uXryIxx57DIWFhYiJiWnXOaxhEUxERETkJgajBFgY9bV0sxwBL7zwAnr06IGHH34YkiSZPRzkatnZ2e0+N4tgIiIiIjcxTYdoO/+3vdMhvMV9990HSZJw5MgRqzHtmVN8Na8pgjupG6FUm/4JoqWvGoP95Xk5gX46NBp+nv9iKS7QT2d67URcY3DzsjNOxLX8k4kzca0/05E4W31nb5yj18JTccwB5gBzgDnAHLgxc+AXah06AtG8WdpPbe3ateu6ndtrimAiIiIiTxNGCcLCqK+lfXR9cYk0IiIiIjcRRglGCxuL4LYyMzNRV1dnd/zcuXPx008/2R3PIpiIiIjITVpWh7C0kbm//OUvuHLlit3xq1evxqVLl+yO53QIIiIiIjfhdAj7CSHQt29fu298a8+oMeBAEdzU1ISNGzciMTFRfi61o/bs2YPXXnsNxcXFKC8vR15eHh566CH5uBACCxYswDvvvCMv8rx69WoMGDDAqc8lIiIi8gQWwfazthyaLWFhYXbHtrsI9vHxwVNPPYVjx461961t1NXVYeDAgXj88ccxceLENseXLl2K7Oxs5Obmom/fvli0aBFGjx6N48ePmz3txB4KCCgkASMApcIIAGhUC+h/YUo6X6UBhqv+OcJSnK/SAABOxTWqTfd/OhNnbP5OzsQZmj/PmbjWfedInK1rYW+crWvh6jjmgP3X1t445gBzgDnAHHBHDgQ290uHwKUg7JKamnpdz+/QdIghQ4bg0KFD6Nmzp1MfPnbsWIwdO9biMSEEVqxYgRdffBETJkwAAKxbtw5hYWHYtGkTpk6d6tRnExEREbkbR4I7DoeK4IyMDGRmZqKsrAyDBg1CQECA2fHbb7/d6YaVlpaioqJCfk41AKjVasTFxWHv3r1Wi2CdTged7ue1AGtqapxuCxEREZFLCMm0WdpPbuVQEfzII48AAGbMmCHvkyQJQghIkgSDwfl/cqioqADQdm5HWFgYTp8+bfV9S5YswYIFC5z+fCIiIiKX49MyOgyHiuDS0lJXt8Oq1ncEthTa1sydOxeZmZny65qaGkRGRl639hERERHZi9MhOg6HimBn5wLbo2XliYqKCkRERMj7Kysrbd75p1aroVarr3v7iIiIiNqNI8EdhkNF8Pr1620enzx5skONuVpUVBTCw8NRUFCAO+64AwDQ2NiI3bt349VXX3X6/ERERETuJhklSBZGfS3t83YtCyPYY8uWLe0+v0NF8DPPPGP2Wq/X48qVK1CpVOjUqZPdRfDly5fx3Xffya9LS0tx6NAhhISEoEePHpg5cyYWL16MPn36oE+fPli8eDE6deqE5OTkdrdZkgQkSUABQCGZfm4JBWBsHjRWKQxogA+k5mOW4lQK01xnZ+JE8zP6nIlrecyfM3ENzZfembjWfedInK1rYW+crWvh6jjmgHkcc4A5wBxgDtxIOdAhGCXTZmk/mdFoNPKfhRDIy8uDRqPB4MGDAQDFxcW4dOlSu4rlqzlUBFdVVbXZd/LkSTz11FN47rnn7D7P119/jfj4ePl1y1ze1NRU5ObmYs6cOaivr0dGRob8sIz8/Px2rxFMRERE1CFwOoTdrn5YxvPPP4+HH34Yb731FpRKJQDAYDAgIyMDQUFBDp3fZY9N7tOnD1555RVMmjQJ//nPf+x6z4gRIyCE9asuSRKysrKQlZXlolYSEREReZCxebO0n6x6//33UVhYKBfAAKBUKpGZmYlhw4bhtddea/c5FdcOsZ9SqcS5c+dceUoiIiKim0bLnGBLG1nX1NRk8WnFx44dg9Ho2C8Ih0aCP/30U7PXQgiUl5dj1apVGD58uEMNISIiIrrpcTqEQx5//HFMmTIF3333HYYOHQoAKCoqwiuvvILHH3/coXM6VAQ/9NBDZq8lSULXrl0xcuRILF++3KGGEBEREd3sJACShYKX48C2LVu2DOHh4Xj99ddRXl4OAIiIiMCcOXMwa9Ysh87pUBHs6LCzJzXofaFs9IVRSGgymGaBSFf9GqvTq3BFp5LvKLUUV6dXAYBTcXLiOxFnbH60ojNxV3SmWKfiWvWdI3G2roW9cbauhavjmAPMAeYAc4A5cOPmQIfA1SEcolAoMGfOHMyZMwc1NTUA4PANcS2cvjGu5cY2W09xIyIiIiJwOoQLOFv8tnD4xrj169cjJiYG/v7+8Pf3x+23344PPvjAJY0iIiIiuhlJRusbWXf+/HmkpKRAq9XCx8cHSqXSbHOEQyPB2dnZeOmllzB9+nQMHz4cQgj8+9//xpNPPokLFy7g2WefdagxRERERDczawUvi2Db0tLScObMGbz00kuIiIhwyQwEh4rgnJwcvPnmm2ZPhnvwwQcxYMAAZGVlsQgmIiIiskRIps3SfrKqsLAQ//rXv/DrX//aZed0qAguLy/HsGHD2uwfNmyYfMceEREREZnjSLBjIiMjbT5gzREOFcG33norPvroI8ybN89s/4cffog+ffq4pGGu1mRUQBgVMBol6PWmuSMKnQRFo+m4AKBvUkKpNGWhpbiWrncmTqEz/dJzJs7YfAepM3H6JlObnYlr3XeOxNm6FvbG2boWro5jDjAHmAPMAebAjZsDHYK1+b8sgm1asWIFXnjhBbz99tvo1auXS87p0I1xCxYswJ/+9CeMGTMGf/7zn7Fo0SKMGTMGCxYswMKFC13SMCIiIqKbjrCxtUNWVhYkSTLbwsPDf/4YIZCVlQWtVgt/f3+MGDECR44cMTuHTqfD008/jS5duiAgIADjx4/H2bNnzWKqqqqQkpICjUYDjUaDlJQUXLp0ySzmzJkzeOCBBxAQEIAuXbpgxowZaGxsNIs5fPgw4uLi4O/vj27dumHhwoXtGtl95JFHsGvXLvTu3RuBgYEICQkx2xzh0EjwxIkTsW/fPrz++uv45JNPIIRA//79sX//ftxxxx0ONYSIiIjoZufK6RADBgzAtm3b5NdXr5KwdOlSZGdnIzc3F3379sWiRYswevRoHD9+HIGBgQCAmTNn4rPPPsPmzZtxyy23YNasWUhKSkJxcbF8ruTkZJw9exZbt24FAPzP//wPUlJS8NlnnwEADAYDxo0bh65du6KwsBAXL15EamoqhBDIyckBANTU1GD06NGIj4/HgQMHcOLECaSlpSEgIMDuB12sWLGi/R10De0qglsWJwaAPn364I033rAY46r124iIiIhuKi5cJ9jHx8ds9Fc+lRBYsWIFXnzxRUyYMAEAsG7dOoSFhWHTpk2YOnUqqqursWbNGnzwwQe4//77AQAbNmxAZGQktm3bhsTERBw7dgxbt25FUVERhgwZAgB49913ERsbi+PHj6Nfv37Iz8/H0aNHUVZWBq1WCwBYvnw50tLS8PLLLyMoKAgbN25EQ0MDcnNzoVarER0djRMnTiA7OxuZmZl2rfSQmpra/g66hnZNh+jcuTOCg4OvuRERERFRW5KwvgGmwcSrN51OZ/VcJ0+ehFarRVRUFB599FF8//33AIDS0lJUVFQgISFBjlWr1YiLi8PevXsBAMXFxdDr9WYxWq0W0dHRcsxXX30FjUYjF8AAMHToUGg0GrOY6OhouQAGgMTEROh0OhQXF8sxcXFxUKvVZjHnzp3DqVOn2t2H9fX1bfrJEe0aCd65c6f8ZyEEfvOb3+C9995Dt27dHPpwIiIiIq8iYPkmuOYiODIy0mz3/PnzkZWV1SZ8yJAhWL9+Pfr27Yvz589j0aJFGDZsGI4cOYKKigoAQFhYmNl7wsLCcPr0aQBARUUFVCpVm8HLsLAw+f0VFRUIDQ1t89mhoaFmMa0/Jzg4GCqVyiym9c1sLe+pqKhAVFSUhQ4xV1dXh+effx4fffQRLl682Oa4wWC45jlaa1cRHBcXZ/ZaqVRi6NCh+OUvf9nuDyYiIiLyNteaE1xWVmY2rfTq0dOrjR07Vv5zTEwMYmNj0bt3b6xbtw5Dhw41nbPVNAMhxDWnHrSOsRTvipiWm+LsfejFnDlzsHPnTrzxxhuYPHkyVq9ejR9++AFvv/02XnnlFbvO0ZpDN8bdiAwGCTCYlkgzNC+d4tsAKJv/lUFvUKKp6efZIZbi9AbTa2fifBtMr52Ja1l2xpm41p/pSJytvrM3ztFr4ak45gBzgDnAHGAO3Jg50GR07NG6rnb11IfW+wEgKCjIoXurAgICEBMTg5MnT+Khhx4CYBpljYiIkGMqKyvlEdjw8HA0NjaiqqrKbDS4srJSfhZEeHg4zp8/3+azfvzxR7Pz7Nu3z+x4VVUV9Hq9WUzLqPDVnwO0Ha225rPPPsP69esxYsQITJkyBffeey9uvfVW9OzZExs3bsRjjz1m13mu5tASaURERETkAKONzQk6nQ7Hjh1DREQEoqKiEB4ejoKCAvl4Y2Mjdu/eLRe4gwYNgq+vr1lMeXk5SkpK5JjY2FhUV1dj//79csy+fftQXV1tFlNSUmL2sLT8/Hyo1WoMGjRIjtmzZ4/Zsmn5+fnQarV2r/n7008/ydMmgoKC8NNPPwEA7rnnHuzZs8fufrqa00WwK57dTEREROQNWqZDWNraY/bs2di9ezdKS0uxb98+/O53v0NNTQ1SU1MhSRJmzpyJxYsXIy8vDyUlJUhLS0OnTp2QnJwMANBoNHjiiScwa9YsbN++HQcPHsSkSZMQExMjrxZx2223YcyYMUhPT0dRURGKioqQnp6OpKQk9OvXDwCQkJCA/v37IyUlBQcPHsT27dsxe/ZspKenyyPaycnJUKvVSEtLQ0lJCfLy8rB48WK7V4YAgF/+8pfyTXT9+/fHRx99BMA0Qty5c+f2dV6zdk2HaFlmo0VDQwOefPJJBAQEmO3fsmWLQ40hIiIiuqm5aIm0s2fP4g9/+AMuXLiArl27YujQoSgqKkLPnj0BmObQ1tfXIyMjA1VVVRgyZAjy8/PlNYIB4PXXX4ePjw8efvhh1NfXY9SoUcjNzTVbb3jjxo2YMWOGvIrE+PHjsWrVKvm4UqnEF198gYyMDAwfPhz+/v5ITk7GsmXL5BiNRoOCggJMmzYNgwcPRnBwMDIzM5GZmWn393388cfxf//3f4iLi8PcuXMxbtw45OTkoKmpCdnZ2e3rvGbtKoI1Go3Z60mTJjn0oURERETeyFUPy9i8ebPtz5EkZGVlWVxZooWfnx9ycnLkh1pYEhISgg0bNtj8rB49euDzzz+3GRMTE+PwtAUAePbZZ+U/x8fH4z//+Q++/vpr9O7dGwMHDnTonO0qgteuXevQh1izZ88evPbaayguLkZ5eTny8vLkydwAkJaWhnXr1pm9Z8iQISgqKnJpO4iIiIjcwZVPjPNmPXr0QI8ePZw6h0dXh6irq8PAgQPx+OOPY+LEiRZjxowZY1Z8q1Qqhz7LoFdC6JUwCgnGRtMwv7IRUDSZjuublDA0KQFhmptiKU7fZHrtTJyyeU64M3HGllgn4gzNsc7Etek7B+JsXgt742xcC1fHMQeYA8wB5gBz4MbNgQ7BhU+M8zb79+/Hrl27UFlZCaPR/FeDI1MiPFoEjx071mydO0vUarXFRwISERER3WiutUQaWbZ48WL8v//3/9CvXz+EhYVdc51ie3T4dYJ37dqF0NBQdO7cGXFxcXj55ZctPr2khU6nM3vEoKOP0iMiIiJyNU6HcMxf/vIXvP/++0hLS3PZOTv0OsFjx47Fxo0bsWPHDixfvhwHDhzAyJEjbT5He8mSJdBoNPLW+vGDRERERB4lLGxkk0KhwPDhw117TpeezcUeeeQRjBs3DtHR0XjggQfw5Zdf4sSJE/jiiy+svmfu3Lmorq6Wt7KyMje2mIiIiMg6V60T7G2effZZrF692qXn7PDTIa4WERGBnj174uTJk1Zj1Gq11edsExEREXkSp0M4Zvbs2Rg3bhx69+6N/v37w9fX1+y4I8+ouKGK4IsXL6KsrMzsOdhERERENwreGOeYp59+Gjt37kR8fDxuueUWlzyx2KNF8OXLl/Hdd9/Jr0tLS3Ho0CGEhIQgJCQEWVlZmDhxIiIiInDq1CnMmzcPXbp0wW9/+9t2f5ZRSICQIIwSYGjbcU1GBYRRglFhOmYprsmokI95Mk4Ym487EddyzONxNq6FvXG2+s7VccwB5gBzgDnAHLhxc6BDMDZvlvaTVevXr8fHH3+McePGueycHi2Cv/76a8THx8uvWx6fl5qaijfffBOHDx/G+vXrcenSJURERCA+Ph4ffvih2SP/iIiIiG4UnA7hmJCQEPTu3dul5/RoETxixAgIYX38/5///KcbW0NERER0fUlCQLJQ+1jaRz/LysrC/PnzsXbtWnTq1Mkl57yh5gQTERER3cg4EuyYlStX4r///S/CwsLQq1evNjfGffPNN+0+J4tgIiIiIjdhEeyYhx56yOXnZBFMRERE5C7WHo7B2RA2zZ8/3+Xn9Joi2FfVBKWqCQaDAnqV6Q5RgxowNo+mq32aoFM1wcfH9FPMUpzapwkAnIozNC9h7EycwWD6PGfidCpTrDNxrfvOkThb18LeOFvXwtVxzAHmAHOAOcAcuDFzQNXcL57GkWDHXbp0CX/729/w3//+F8899xxCQkLwzTffICwsDN26dWv3+bymCCYiIiLyOCEgGS0M+/LGOJu+/fZb3H///dBoNDh16hTS09MREhKCvLw8nD59GuvXr2/3OTvIonlEREREN7+Wh2VY2si6zMxMpKWl4eTJk/Dz85P3jx07Fnv27HHonBwJJiIiInITyQBIFoYgJYP723IjOXDgAN5+++02+7t164aKigqHzskimIiIiMhNOCfYMX5+fqipqWmz//jx4+jatatD5+R0CCIiIiJ3EcL6RlY9+OCDWLhwIfR6PQBAkiScOXMGL7zwAiZOnOjQOb1mJDhcUwufgEboDUpcUpvmktR19ZX/+eHWoGpcUjdCqTD9FLMUd2tQNQA4FVfX1XSbqjNxeoOy+bXjcZfUjQDgVFzrvnMkzta1sDfO1rVwdRxzgDnAHGAOMAduzBzoF1iDw/A8jgQ7ZtmyZfjNb36D0NBQ1NfXIy4uDhUVFYiNjcXLL7/s0Dm9pggmIiIi8jTJaHl1CIsrRpAsKCgIhYWF2LFjB7755hsYjUbceeeduP/++x0+J4tgIiIiIjexthIEV4ewz8iRIzFy5EiXnItFMBEREZGbcDpE+xmNRuTm5mLLli04deoUJElCVFQUfve73yElJQWSJDl0Xt4YR0REROQuBmF9ozaEEBg/fjz++Mc/4ocffkBMTAwGDBiA06dPIy0tDb/97W8dPjdHgomIiIjcRIKV6RBub8mNITc3F3v27MH27dsRHx9vdmzHjh146KGHsH79ekyePLnd5+ZIMBEREZGbtNwYZ2mjtv76179i3rx5bQpgwDQ/+IUXXsDGjRsdOrfXjAQrJCFvLb+2hK+AUJn+7Oejh2+Tyiy+dZyfj2ltOmfihK8pyZ2JUzT/hHQmrvVnOhJnq+/sjXP0WngqjjnAHGAOMAeYAzduDnQEXB2ifb799lssXbrU6vGxY8di5cqVDp2bI8FERERE7mK0sTloyZIlkCQJM2fOlPcJIZCVlQWtVgt/f3+MGDECR44cMXufTqfD008/jS5duiAgIADjx4/H2bNnzWKqqqqQkpICjUYDjUaDlJQUXLp0ySzmzJkzeOCBBxAQEIAuXbpgxowZaGxsNIs5fPgw4uLi4O/vj27dumHhwoUQdjwg5KeffkJYWJjV42FhYaiqqrrmeSxhEUxERETkJq6eDnHgwAG88847uP322832L126FNnZ2Vi1ahUOHDiA8PBwjB49GrW1tXLMzJkzkZeXh82bN6OwsBCXL19GUlISDAaDHJOcnIxDhw5h69at2Lp1Kw4dOoSUlBT5uMFgwLhx41BXV4fCwkJs3rwZH3/8MWbNmiXH1NTUYPTo0dBqtThw4ABycnKwbNkyZGdnX/P7GQwG+PhYn7igVCrR1NRkV1+15jXTIYiIiIg8zZXTIS5fvozHHnsM7777LhYtWiTvF0JgxYoVePHFFzFhwgQAwLp16xAWFoZNmzZh6tSpqK6uxpo1a/DBBx/ID5zYsGEDIiMjsW3bNiQmJuLYsWPYunUrioqKMGTIEADAu+++i9jYWBw/fhz9+vVDfn4+jh49irKyMmi1WgDA8uXLkZaWhpdffhlBQUHYuHEjGhoakJubC7VajejoaJw4cQLZ2dnIzMy0ucSZEAJpaWlQq9UWj+t0unb3WwuOBBMRERG5ixDWN5hGTa/ebBV506ZNw7hx49o8Na20tBQVFRVISEiQ96nVasTFxWHv3r0AgOLiYuj1erMYrVaL6OhoOearr76CRqORC2AAGDp0KDQajVlMdHS0XAADQGJiInQ6HYqLi+WYuLg4s0I2MTER586dw6lTp2x2V2pqKkJDQ+XpGK230NBQh1aGADw8ErxkyRJs2bIF//nPf+Dv749hw4bh1VdfRb9+/eQYIQQWLFiAd955B1VVVRgyZAhWr16NAQMGeLDlRERERO0nGQQkC2ukSc3rBEdGRprtnz9/PrKystrEb968Gd988w0OHDjQ5lhFRQUAtJlLGxYWhtOnT8sxKpUKwcHBbWJa3l9RUYHQ0NA25w8NDTWLaf05wcHBUKlUZjG9evVq8zktx6Kiotp8Rou1a9daPeYsjxbBu3fvxrRp03DXXXehqakJL774IhISEnD06FEEBAQA+HlOS25uLvr27YtFixZh9OjROH78OAIDA+3+rPO1gVAa1DAYFGioM90q6lOrgLH5DtiztZ1R06CGEKYheUtxZ2s7A4BTcT61psF3Z+IMBtMxZ+JqGky/xpyJa913jsTZuhb2xtm6Fq6OYw4wB5gDzAHmwI2ZAz/UatARXGs6RFlZGYKCguT9lqYBlJWV4ZlnnkF+fj78/Pysf1araQZCiGs+Xa11jKV4V8S03BTn6NPeXMGj0yG2bt2KtLQ0DBgwAAMHDsTatWtx5swZefi89ZyW6OhorFu3DleuXMGmTZs82XQiIiKi9rvGdIigoCCzzVIRXFxcjMrKSgwaNAg+Pj7w8fHB7t27sXLlSvj4+JiNsl6tsrJSPhYeHo7GxsY2Kyu0jjl//nybz//xxx/NYlp/TlVVFfR6vc2YyspKAG1Hq92pQ80Jrq6uBgCEhIQAsG9OS2s6na7NfBoiIiKijkAyCtOUiNZbO26MGzVqFA4fPoxDhw7J2+DBg/HYY4/h0KFD+OUvf4nw8HAUFBTI72lsbMTu3bsxbNgwAMCgQYPg6+trFlNeXo6SkhI5JjY2FtXV1di/f78cs2/fPlRXV5vFlJSUoLy8XI7Jz8+HWq3GoEGD5Jg9e/aYLZuWn58PrVbbZpqEO3WYIlgIgczMTNxzzz2Ijo4GYHtOS+tfFC2WLFliNmG69dwaIiIiIo8xCsBotLDZXwQHBgYiOjrabAsICMAtt9yC6Ohoec3gxYsXIy8vDyUlJUhLS0OnTp2QnJwMANBoNHjiiScwa9YsbN++HQcPHsSkSZMQExMj32h32223YcyYMUhPT0dRURGKioqQnp6OpKQk+f6thIQE9O/fHykpKTh48CC2b9+O2bNnIz09XZ7WkZycDLVajbS0NJSUlCAvLw+LFy++5soQ11uHWSJt+vTp+Pbbb1FYWNjmWHvmtMydOxeZmZny65qaGhbCRERE1DEYAVgqYZx4WIYlc+bMQX19PTIyMuSFBfLz883up3r99dfh4+ODhx9+GPX19Rg1ahRyc3OhVCrlmI0bN2LGjBnyv8qPHz8eq1atko8rlUp88cUXyMjIwPDhw+Hv74/k5GQsW7ZMjtFoNCgoKMC0adMwePBgBAcHIzMz06xe84QOUQQ//fTT+PTTT7Fnzx50795d3h8eHg7ANCIcEREh7796vkprarXa6lpyRERERJ4kGY2QpLYVr2R0rgretWuX+fkkCVlZWRZXlmjh5+eHnJwc5OTkWI0JCQnBhg0bbH52jx498Pnnn9uMiYmJwZ49e2zGuJtHp0MIITB9+nRs2bIFO3bsaLNERlRU1DXntBARERHdMCxOhWjeyK08OhI8bdo0bNq0CX//+98RGBgoz/PVaDTw9/c3m9PSp08f9OnTB4sXLzab02KvugudoPD3A4wSFA2m2t+3RoJRZfo3iYqfgmCo8wVapuRYiKv4yTS3xZk43xrT5zkVZzQdcybOUOdr+jwn4tr0nQNxNq+FvXE2roWr45gDzAHmAHOAOXBj5kBllf3Lql5XbpoOQdfm0SL4zTffBACMGDHCbP/atWuRlpYGwL45LUREREQ3gus1HYLaz6NFcMtCybbYM6eFiIiI6IZgMMLisK+BRbC7dYgb44iIiIi8w88Pxmizn9yKRTARERGRuxiMgLAw6svpEG7HIpiIiIjIXYwGAAYr+8mdvKYIVl5WQtGkBASgaGy+Y7UJ8h2ahlpfKK4oIc9VtxBnqDXdpepMnKKp+bUzcc3/YuJMnOKKaSFsp+Ja9Z0jcbauhb1xtq6Fq+OYA63imAMOxTEHmAPMAQ/kwOXmlSY8zShgcepDO54YR67hNUUwERERkccZBSzeGMci2O1YBBMRERG5i8EACE6H6AhYBBMRERG5i7CyOoQdy8aSa7EIJiIiInIXrg7RYbAIJiIiInITIYwQFopgS/vo+mIRTEREROQuRisjwSyC3c5rimDfKgWUagUAQNE899y3VsDoa1o7xafKB751ktkNm63jfKpM3eVMnG+tac6Pp+N865rXjHEirk3fORBn81rYG2fjWrg6jjlgHscccCyOOcAcYA54IAdUHaTkMRgAycJNcJZulqPrqoNkBBEREdHNTxiNEJKx7X6OBLsdi2AiIiIidzEYAQtFMKdDuB+LYCIiIiI3EQYjhIXpEBwJdj8WwURERETuIoyw+MQ4FsFud9MXwaJ58WmjruHnfc0/wAyNAkajacK8sUHAoDOfWN86zthgOpczcYbG5vZ4OM6ga3vzQnvj2vSdA3E2r4W9cTauhavjmAPmccwBx+KYA8wB5oAncsBUBwgPP5RCb2iAQNuR4CboPdAa73bTF8G1tbUAgO9XLvRwS4iIiMjTamtrodFo3P65KpUK4eHhKKz4h9WY8PBwqFQqN7bKu0nC0z+JrjOj0Yjjx4+jf//+KCsrQ1BQkKeb1KHU1NQgMjKSfdMK+8U69o117Bvr2DfWsW+sc2XfCCFQW1sLrVYLhULhoha2T0NDAxobG60eV6lU8PPzc2OLvNtNPxKsUCjQrVs3AEBQUBD/grGCfWMZ+8U69o117Bvr2DfWsW+sc1XfeGIE+Gp+fn4scjsQz/wUIiIiIiLyIBbBREREROR1vKIIVqvVmD9/PtRqtaeb0uGwbyxjv1jHvrGOfWMd+8Y69o117Bu6nm76G+OIiIiIiFrzipFgIiIiIqKrsQgmIiIiIq/DIpiIiIiIvA6LYCIiIiLyOjd9EfzGG28gKioKfn5+GDRoEP71r395uklul5WVBUmSzLbw8HD5uBACWVlZ0Gq18Pf3x4gRI3DkyBEPtvj62bNnDx544AFotVpIkoRPPvnE7Lg9faHT6fD000+jS5cuCAgIwPjx43H27Fk3fovr41p9k5aW1iaPhg4dahZzM/bNkiVLcNdddyEwMBChoaF46KGHcPz4cbMYb80be/rGW/PmzTffxO233y4/5CE2NhZffvmlfNxbcwa4dt94a86Q+93URfCHH36ImTNn4sUXX8TBgwdx7733YuzYsThz5oynm+Z2AwYMQHl5ubwdPnxYPrZ06VJkZ2dj1apVOHDgAMLDwzF69GjU1tZ6sMXXR11dHQYOHIhVq1ZZPG5PX8ycORN5eXnYvHkzCgsLcfnyZSQlJcFgMLjra1wX1+obABgzZoxZHv3jH/8wO34z9s3u3bsxbdo0FBUVoaCgAE1NTUhISEBdXZ0c4615Y0/fAN6ZN927d8crr7yCr7/+Gl9//TVGjhyJBx98UC50vTVngGv3DeCdOUMeIG5id999t3jyySfN9v3qV78SL7zwgoda5Bnz588XAwcOtHjMaDSK8PBw8corr8j7GhoahEajEW+99ZabWugZAEReXp782p6+uHTpkvD19RWbN2+WY3744QehUCjE1q1b3db266113wghRGpqqnjwwQetvsdb+qayslIAELt37xZCMG+u1rpvhGDeXC04OFi89957zBkLWvpGCOYMuc9NOxLc2NiI4uJiJCQkmO1PSEjA3r17PdQqzzl58iS0Wi2ioqLw6KOP4vvvvwcAlJaWoqKiwqyf1Go14uLivK6f7OmL4uJi6PV6sxitVovo6Giv6K9du3YhNDQUffv2RXp6OiorK+Vj3tI31dXVAICQkBAAzJurte6bFt6eNwaDAZs3b0ZdXR1iY2OZM1dp3TctvD1nyD18PN2A6+XChQswGAwICwsz2x8WFoaKigoPtcozhgwZgvXr16Nv3744f/48Fi1ahGHDhuHIkSNyX1jqp9OnT3uiuR5jT19UVFRApVIhODi4TczNnldjx47F73//e/Ts2ROlpaV46aWXMHLkSBQXF0OtVntF3wghkJmZiXvuuQfR0dEAmDctLPUN4N15c/jwYcTGxqKhoQG/+MUvkJeXh/79+8uFmjfnjLW+Abw7Z8i9btoiuIUkSWavhRBt9t3sxo4dK/85JiYGsbGx6N27N9atWyffbMB++pkjfeEN/fXII4/If46OjsbgwYPRs2dPfPHFF5gwYYLV991MfTN9+nR8++23KCwsbHPM2/PGWt94c97069cPhw4dwqVLl/Dxxx8jNTUVu3fvlo97c85Y65v+/ft7dc6Qe9200yG6dOkCpVLZ5ldhZWVlm1/f3iYgIAAxMTE4efKkvEoE+wl29UV4eDgaGxtRVVVlNcZbREREoGfPnjh58iSAm79vnn76aXz66afYuXMnunfvLu9n3ljvG0u8KW9UKhVuvfVWDB48GEuWLMHAgQPxl7/8hTkD631jiTflDLnXTVsEq1QqDBo0CAUFBWb7CwoKMGzYMA+1qmPQ6XQ4duwYIiIiEBUVhfDwcLN+amxsxO7du72un+zpi0GDBsHX19cspry8HCUlJV7XXxcvXkRZWRkiIiIA3Lx9I4TA9OnTsWXLFuzYsQNRUVFmx705b67VN5Z4S95YIoSATqfz6pyxpqVvLPHmnKHrzO234rnR5s2bha+vr1izZo04evSomDlzpggICBCnTp3ydNPcatasWWLXrl3i+++/F0VFRSIpKUkEBgbK/fDKK68IjUYjtmzZIg4fPiz+8Ic/iIiICFFTU+PhlrtebW2tOHjwoDh48KAAILKzs8XBgwfF6dOnhRD29cWTTz4punfvLrZt2ya++eYbMXLkSDFw4EDR1NTkqa/lErb6pra2VsyaNUvs3btXlJaWip07d4rY2FjRrVu3m75vnnrqKaHRaMSuXbtEeXm5vF25ckWO8da8uVbfeHPezJ07V+zZs0eUlpaKb7/9VsybN08oFAqRn58vhPDenBHCdt94c86Q+93URbAQQqxevVr07NlTqFQqceedd5ot3eMtHnnkERERESF8fX2FVqsVEyZMEEeOHJGPG41GMX/+fBEeHi7UarW47777xOHDhz3Y4utn586dAkCbLTU1VQhhX1/U19eL6dOni5CQEOHv7y+SkpLEmTNnPPBtXMtW31y5ckUkJCSIrl27Cl9fX9GjRw+Rmpra5nvfjH1jqU8AiLVr18ox3po31+obb86bKVOmyP/f07VrVzFq1Ci5ABbCe3NGCNt94805Q+4nCSGE+8adiYiIiIg876adE0xEREREZA2LYCIiIiLyOiyCiYiIiMjrsAgmIiIiIq/DIpiIiIiIvA6LYCIiIiLyOiyCiYiIiMjrsAgmIiIiIq/DIpiIiIiIvA6LYCK6IaWlpUGSJEiSBF9fX4SFhWH06NF4//33YTQaPd08IiLq4FgEE9ENa8yYMSgvL8epU6fw5ZdfIj4+Hs888wySkpLQ1NTk6eYREVEHxiKYiG5YarUa4eHh6NatG+68807MmzcPf//73/Hll18iNzcXAJCdnY2YmBgEBAQgMjISGRkZuHz5MgCgrq4OQUFB+Nvf/mZ23s8++wwBAQGora1191ciIiI3YRFMRDeVkSNHYuDAgdiyZQsAQKFQYOXKlSgpKcG6deuwY8cOzJkzBwAQEBCARx99FGvXrjU7x9q1a/G73/0OgYGBbm8/ERG5hySEEJ5uBBFRe6WlpeHSpUv45JNP2hx79NFH8e233+Lo0aNtjv3v//4vnnrqKVy4cAEAsH//fgwbNgxnzpyBVqvFhQsXoNVqUVBQgLi4uOv9NYiIyEM4EkxENx0hBCRJAgDs3LkTo0ePRrdu3RAYGIjJkyfj4sWLqKurAwDcfffdGDBgANavXw8A+OCDD9CjRw/cd999Hms/ERFdfyyCieimc+zYMURFReH06dP4zW9+g+joaHz88ccoLi7G6tWrAQB6vV6O/+Mf/yhPiVi7di0ef/xxuYgmIqKbE4tgIrqp7NixA4cPH8bEiRPx9ddfo6mpCcuXL8fQoUPRt29fnDt3rs17Jk2ahDNnzmDlypU4cuQIUlNTPdByIiJyJx9PN4CIyFE6nQ4VFRUwGAw4f/48tm7diiVLliApKQmTJ0/G4cOH0dTUhJycHDzwwAP497//jbfeeqvNeYKDgzFhwgQ899xzSEhIQPfu3T3wbYiIyJ04EkxEN6ytW7ciIiICvXr1wpgxY7Bz506sXLkSf//736FUKvHrX/8a2dnZePXVVxEdHY2NGzdiyZIlFs/1xBNPoLGxEVOmTHHztyAiIk/g6hBERAA2btyIZ555BufOnYNKpfJ0c4iI6DrjdAgi8mpXrlxBaWkplixZgqlTp7IAJiLyEpwOQURebenSpfj1r3+NsLAwzJ0719PNISIiN+F0CCIiIiLyOhwJJiIiIiKvwyKYiIiIiLwOi2AiIiIi8josgomIiIjI67AIJiIiIiKvwyKYiIiIiLwOi2AiIiIi8josgomIiIjI6/x/EqL1d2JMhjMAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "plotTS(predictedPeriods['Demand'], 24, vmin = dfProfiles['Demand'].min(), vmax = dfProfiles['Demand'].max())" - ] - }, - { - "cell_type": "markdown", - "id": "a502e725", - "metadata": {}, - "source": [ - "#### Show the resulting order of aggregated periods" + "typPeriods.to_csv(os.path.join(CASE, f\"oT_Aggr_TypicalPeriods_{CaseName}.csv\"))\n", + "print(\"written:\", f\"oT_Aggr_TypicalPeriods_{CaseName}.csv\")" ] }, { "cell_type": "markdown", - "id": "8f52bd95", + "id": "f206e4ad", "metadata": {}, "source": [ + "## How well does it match?\n", "\n", - "###### Calculates how the original index is represented by the old index" - ] - }, - { - "cell_type": "code", - "execution_count": 444, - "id": "0dc8ecbd", - "metadata": {}, - "outputs": [], - "source": [ - "indexMatching = aggregation.indexMatching()" - ] - }, - { - "cell_type": "markdown", - "id": "e22f27bc", - "metadata": {}, - "source": [ - "##### Plot the appearance of the 5+2 aggregated periods in the original timeframe" - ] - }, - { - "cell_type": "code", - "execution_count": 445, - "id": "652f14bd", - "metadata": {}, - "outputs": [], - "source": [ - "visDF = pd.DataFrame(0, index = indexMatching.index,\n", - " columns = aggregation.clusterPeriodIdx)\n", - "for col in visDF.columns:\n", - " visDF.loc[indexMatching['PeriodNum']==col,col] = 1" + "A duration curve sorts demand from highest to lowest hour. If the four typical weeks capture the year well, their duration curve should track the original closely." ] }, { "cell_type": "code", - "execution_count": 446, - "id": "d026fe38", - "metadata": {}, + "execution_count": 6, + "id": "6d3cc327", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-29T20:33:41.469224Z", + "iopub.status.busy": "2026-06-29T20:33:41.469166Z", + "iopub.status.idle": "2026-06-29T20:33:41.514440Z", + "shell.execute_reply": "2026-06-29T20:33:41.514031Z" + } + }, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "" - ] - }, - "execution_count": 446, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -97179,126 +442,104 @@ } ], "source": [ + "predicted = aggregation.predictOriginalData()\n", "\n", - "visDF.plot(kind = 'area', cmap = 'viridis', lw = 0, ylim = [0,1])" + "fig, ax = plt.subplots(figsize=(9, 5))\n", + "profiles[\"Demand\"].sort_values(ascending=False).reset_index(drop=True).plot(ax=ax, lw=3, label=\"Original (8736 h)\")\n", + "predicted[\"Demand\"].sort_values(ascending=False).reset_index(drop=True).plot(ax=ax, label=\"4 typical weeks\")\n", + "ax.set_xlabel(\"Hours [h]\")\n", + "ax.set_ylabel(\"Demand [MW]\")\n", + "ax.legend()\n", + "plt.show()" ] }, { "cell_type": "markdown", - "id": "c1022790", - "metadata": {}, - "source": [ - "#### Get input for potential energy system optimization" - ] - }, - { - "cell_type": "code", - "execution_count": 447, - "id": "99a10a01", + "id": "07aeeb91", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{0: 52}" - ] - }, - "execution_count": 447, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "aggregation.clusterPeriodNoOccur" + "## How often does each typical week occur?\n", + "\n", + "Each of the 52 weeks is assigned to one of the four representatives. The number of weeks behind each representative becomes its **weight** in the model." ] }, { "cell_type": "code", - "execution_count": 448, - "id": "0225d3c3", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0])" - ] - }, - "execution_count": 448, - "metadata": {}, - "output_type": "execute_result" + "execution_count": 7, + "id": "1fe93f6e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-29T20:33:41.515508Z", + "iopub.status.busy": "2026-06-29T20:33:41.515453Z", + "iopub.status.idle": "2026-06-29T20:33:41.541171Z", + "shell.execute_reply": "2026-06-29T20:33:41.540811Z" } - ], - "source": [ - "aggregation.clusterPeriodIdx" - ] - }, - { - "cell_type": "code", - "execution_count": 449, - "id": "963f6268", - "metadata": {}, + }, "outputs": [ { "data": { - "text/plain": [ - "[Text(0, 0.5, 'Number of occurence'), Text(0.5, 0, 'Stage index')]" - ] - }, - "execution_count": 449, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "weeks represented: {'st0': 11, 'st1': 16, 'st2': 7, 'st3': 18} total: 52\n" + ] } ], "source": [ - "ax = pd.Series(aggregation.clusterPeriodNoOccur).plot(kind='bar')\n", - "ax.set(ylabel = 'Number of occurence', xlabel = 'Stage index')" + "occur = pd.Series(aggregation.clusterPeriodNoOccur).sort_index()\n", + "occur.index = [\"st\" + str(i) for i in occur.index]\n", + "ax = occur.plot(kind=\"bar\")\n", + "ax.set_xlabel(\"Representative week (stage)\")\n", + "ax.set_ylabel(\"Number of weeks represented\")\n", + "plt.show()\n", + "print(\"weeks represented:\", occur.to_dict(), \" total:\", int(occur.sum()))" ] }, { - "cell_type": "code", - "execution_count": 450, - "id": "c5b2c646", + "cell_type": "markdown", + "id": "ac97c56f", "metadata": {}, - "outputs": [], "source": [ - "a = aggregation.clusterOrder" + "## Write the stage files openTEPES reads\n", + "\n", + "openTEPES drives a stage-based run from three files:\n", + "\n", + "- `oT_Data_Stage` — each stage and its weight (how many weeks it stands for),\n", + "- `oT_Dict_Stage` — the list of stage names,\n", + "- `oT_Data_Duration` — for each hour, which stage it belongs to and whether it is active.\n", + "\n", + "The weeks are contiguous and 168 hours long, so the week of hour *i* is simply `i // 168`. `clusterOrder` tells us which representative each week maps to, and `clusterCenterIndices` are the representative weeks themselves — only those hours stay active (duration 1); the rest collapse to 0 and are stood in for by their representative." ] }, { "cell_type": "code", - "execution_count": 451, - "id": "cf15b2e4", - "metadata": {}, + "execution_count": 8, + "id": "42b419e1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-29T20:33:41.542165Z", + "iopub.status.busy": "2026-06-29T20:33:41.542111Z", + "iopub.status.idle": "2026-06-29T20:33:41.555486Z", + "shell.execute_reply": "2026-06-29T20:33:41.555246Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "size of clusterOrder: 52 order of clusters: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n" + "stage files written to work_TSAM/9n_ByStages\n" ] - } - ], - "source": [ - "print('size of clusterOrder: ', len(a), 'order of clusters: ', a)" - ] - }, - { - "cell_type": "code", - "execution_count": 452, - "id": "3483aa60", - "metadata": {}, - "outputs": [ + }, { "data": { "text/html": [ @@ -97320,45326 +561,122 @@ " \n", " \n", " \n", - " \n", - " Demand\n", - " Hydro\n", - " Solar\n", - " Wind\n", - " \n", - " \n", - " \n", - " TimeStep\n", - " \n", - " \n", - " \n", - " \n", + " Stage\n", + " Weight\n", " \n", " \n", " \n", " \n", - " 0\n", " 0\n", - " 470262.948549\n", - " 36267.504805\n", - " 0.000096\n", - " 179621.256731\n", + " st0\n", + " 11\n", " \n", " \n", " 1\n", - " 458700.300093\n", - " 36139.465509\n", - " 0.000096\n", - " 180986.066888\n", + " st1\n", + " 16\n", " \n", " \n", " 2\n", - " 450898.936893\n", - " 36075.445861\n", - " 0.000096\n", - " 184777.354431\n", + " st2\n", + " 7\n", " \n", " \n", " 3\n", - " 448024.526194\n", - " 36075.445861\n", - " 0.000096\n", - " 186529.294820\n", - " \n", - " \n", - " 4\n", - " 451591.159558\n", - " 36075.445861\n", - " 0.000096\n", - " 184835.418310\n", + " st3\n", + " 18\n", " \n", " \n", "\n", "" ], "text/plain": [ - " Demand Hydro Solar Wind\n", - " TimeStep \n", - "0 0 470262.948549 36267.504805 0.000096 179621.256731\n", - " 1 458700.300093 36139.465509 0.000096 180986.066888\n", - " 2 450898.936893 36075.445861 0.000096 184777.354431\n", - " 3 448024.526194 36075.445861 0.000096 186529.294820\n", - " 4 451591.159558 36075.445861 0.000096 184835.418310" - ] - }, - "execution_count": 452, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "aggregation.typicalPeriods.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 453, - "id": "f82ca560", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[9]" + " Stage Weight\n", + "0 st0 11\n", + "1 st1 16\n", + "2 st2 7\n", + "3 st3 18" ] }, - "execution_count": 453, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "aggregation.clusterCenterIndices" + "order = list(aggregation.clusterOrder) # representative id per week (length 52)\n", + "idxs = list(aggregation.clusterPeriodIdx) # the representative ids\n", + "occ = dict(aggregation.clusterPeriodNoOccur) # id -> number of weeks\n", + "centers = set(aggregation.clusterCenterIndices) # week indices that are representatives\n", + "\n", + "BY = os.path.join(WORK, CaseName + \"_ByStages\")\n", + "os.makedirs(BY, exist_ok=True)\n", + "\n", + "# Duration: tag every hour with its representative stage; keep only representative weeks active\n", + "dur = pd.read_csv(os.path.join(CASE, f\"oT_Data_Duration_{CaseName}.csv\"))\n", + "week = np.arange(len(dur)) // HOURS\n", + "dur[\"Stage\"] = [\"st\" + str(order[w]) for w in week]\n", + "dur[\"Duration\"] = [1 if w in centers else 0 for w in week]\n", + "dur.to_csv(os.path.join(BY, f\"oT_Data_Duration_{CaseName}_ByStages.csv\"), index=False)\n", + "\n", + "# Stage weights\n", + "stage = pd.DataFrame({\"Stage\": [\"st\" + str(i) for i in idxs],\n", + " \"Weight\": [int(occ[i]) for i in idxs]})\n", + "stage.to_csv(os.path.join(BY, f\"oT_Data_Stage_{CaseName}_ByStages.csv\"), index=False)\n", + "\n", + "# Stage dictionary\n", + "dict_stage = pd.DataFrame({\"Stage\": [\"st\" + str(i) for i in idxs]})\n", + "dict_stage.to_csv(os.path.join(BY, f\"oT_Dict_Stage_{CaseName}_ByStages.csv\"), index=False)\n", + "\n", + "print(\"stage files written to\", BY)\n", + "stage" ] }, { - "cell_type": "code", - "execution_count": 454, - "id": "9297cf0d", + "cell_type": "markdown", + "id": "1eb191e1", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 454, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "aggregation.extremeClusterIdx" + "## What we got\n", + "\n", + "From a full hourly year we produced four typical weeks and the stage files openTEPES needs to run on them. The active hours dropped from 8 736 to 4 × 168 = 672, a large saving, while the duration curve still follows the original.\n", + "\n", + "Everything was written under `work_TSAM/`, so the committed `9n` case is unchanged. To solve the aggregated case you would point openTEPES at the `9n_ByStages` folder — see [03-Stages](03-Stages.ipynb) for how stages are used in a run." ] }, { "cell_type": "code", - "execution_count": 455, - "id": "50105a5b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'Demand': 'mean', 'Hydro': 'mean', 'Solar': 'mean', 'Wind': 'mean'}" - ] - }, - "execution_count": 455, - "metadata": {}, - "output_type": "execute_result" + "execution_count": 9, + "id": "45c4d3b8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-29T20:33:41.556594Z", + "iopub.status.busy": "2026-06-29T20:33:41.556529Z", + "iopub.status.idle": "2026-06-29T20:33:41.560914Z", + "shell.execute_reply": "2026-06-29T20:33:41.560648Z" } - ], - "source": [ - "aggregation.representationDict" - ] - }, - { - "cell_type": "code", - "execution_count": 456, - "id": "4ae17235", - "metadata": {}, + }, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "c:\\Users\\ealvarezq\\AppData\\Local\\miniconda3\\Lib\\site-packages\\tsam\\timeseriesaggregation.py:1240: FutureWarning: The previous implementation of stack is deprecated and will be removed in a future version of pandas. See the What's New notes for pandas 2.1.0 for details. Specify future_stack=True to adopt the new implementation and silence this warning.\n", - " clustered_data_df = clustered_data_df.stack(level=\"TimeStep\")\n" + "active hours: 672 of 8736 (8% of the year)\n", + "committed 9n still has all 8736 hours active (unchanged)\n" ] } ], "source": [ - "predictedPeriods = aggregation.predictOriginalData()" - ] - }, - { - "cell_type": "code", - "execution_count": 457, - "id": "dfe290ff", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'Duration Load [MW]')" - ] - }, - "execution_count": 457, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(figsize = [10, 6], dpi = 100, nrows = 1, ncols = 1)\n", - "dfProfiles['Demand'].sort_values(ascending=False).reset_index(drop=True).plot(label = 'Original', lw=3)\n", - "predictedPeriods['Demand'].sort_values(ascending=False).reset_index(drop=True).plot(label='4 typ weeks')\n", - "# predictedPeriods2['Demand'].sort_values(ascending=False).reset_index(drop=True).plot(label='8 typ weeks')\n", - "plt.legend()\n", - "plt.xlabel('Hours [h]')\n", - "plt.ylabel('Duration Load [MW]')" - ] - }, - { - "cell_type": "code", - "execution_count": 458, - "id": "9ec17ad3", - "metadata": {}, - "outputs": [], - "source": [ - "dfDuration = pd.read_csv(os.path.join(CaseName, 'oT_Data_Duration_' + CaseName + '.csv'), index_col=[0,1,2])" - ] - }, - { - "cell_type": "code", - "execution_count": 459, - "id": "e1885c1e", - "metadata": {}, - "outputs": [], - "source": [ - "typical_periods_centers = aggregation.clusterCenterIndices\n", - "extreme_periods_centers = aggregation.extremeClusterIdx\n", - "stages = aggregation.clusterPeriodIdx" - ] - }, - { - "cell_type": "code", - "execution_count": 460, - "id": "f101c97f", - "metadata": {}, - "outputs": [], - "source": [ - "b = 'st6'" - ] - }, - { - "cell_type": "code", - "execution_count": 461, - "id": "21cf713e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "6" - ] - }, - "execution_count": 461, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "int(b[2:len(b)])" - ] - }, - { - "cell_type": "code", - "execution_count": 462, - "id": "9a63b1f0", - "metadata": {}, - "outputs": [], - "source": [ - "list_idx = dfDuration.index.tolist()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 463, - "id": "393b055e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[(2030, 'TF', '01-01 00:00:00+01:00'),\n", - " (2030, 'TF', '01-01 01:00:00+01:00'),\n", - " (2030, 'TF', '01-01 02:00:00+01:00'),\n", - " (2030, 'TF', '01-01 03:00:00+01:00'),\n", - " (2030, 'TF', '01-01 04:00:00+01:00'),\n", - " (2030, 'TF', '01-01 05:00:00+01:00'),\n", - " (2030, 'TF', '01-01 06:00:00+01:00'),\n", - " (2030, 'TF', '01-01 07:00:00+01:00'),\n", - " (2030, 'TF', '01-01 08:00:00+01:00'),\n", - " (2030, 'TF', '01-01 09:00:00+01:00'),\n", - " (2030, 'TF', '01-01 10:00:00+01:00'),\n", - " (2030, 'TF', '01-01 11:00:00+01:00'),\n", - " (2030, 'TF', '01-01 12:00:00+01:00'),\n", - " (2030, 'TF', '01-01 13:00:00+01:00'),\n", - " (2030, 'TF', '01-01 14:00:00+01:00'),\n", - " (2030, 'TF', '01-01 15:00:00+01:00'),\n", - " (2030, 'TF', '01-01 16:00:00+01:00'),\n", - " (2030, 'TF', '01-01 17:00:00+01:00'),\n", - " (2030, 'TF', '01-01 18:00:00+01:00'),\n", - " (2030, 'TF', '01-01 19:00:00+01:00'),\n", - " (2030, 'TF', '01-01 20:00:00+01:00'),\n", - " (2030, 'TF', '01-01 21:00:00+01:00'),\n", - " (2030, 'TF', '01-01 22:00:00+01:00'),\n", - " (2030, 'TF', '01-01 23:00:00+01:00'),\n", - " (2030, 'TF', '01-02 00:00:00+01:00'),\n", - " (2030, 'TF', '01-02 01:00:00+01:00'),\n", - " (2030, 'TF', '01-02 02:00:00+01:00'),\n", - " (2030, 'TF', '01-02 03:00:00+01:00'),\n", - " (2030, 'TF', '01-02 04:00:00+01:00'),\n", - " (2030, 'TF', '01-02 05:00:00+01:00'),\n", - " (2030, 'TF', '01-02 06:00:00+01:00'),\n", - " (2030, 'TF', '01-02 07:00:00+01:00'),\n", - " (2030, 'TF', '01-02 08:00:00+01:00'),\n", - " (2030, 'TF', '01-02 09:00:00+01:00'),\n", - " (2030, 'TF', '01-02 10:00:00+01:00'),\n", - " (2030, 'TF', '01-02 11:00:00+01:00'),\n", - " (2030, 'TF', '01-02 12:00:00+01:00'),\n", - " (2030, 'TF', '01-02 13:00:00+01:00'),\n", - " (2030, 'TF', '01-02 14:00:00+01:00'),\n", - " (2030, 'TF', '01-02 15:00:00+01:00'),\n", - " (2030, 'TF', '01-02 16:00:00+01:00'),\n", - " (2030, 'TF', '01-02 17:00:00+01:00'),\n", - " (2030, 'TF', '01-02 18:00:00+01:00'),\n", - " (2030, 'TF', '01-02 19:00:00+01:00'),\n", - " (2030, 'TF', '01-02 20:00:00+01:00'),\n", - " (2030, 'TF', '01-02 21:00:00+01:00'),\n", - " (2030, 'TF', '01-02 22:00:00+01:00'),\n", - " (2030, 'TF', '01-02 23:00:00+01:00'),\n", - " (2030, 'TF', '01-03 00:00:00+01:00'),\n", - " (2030, 'TF', '01-03 01:00:00+01:00'),\n", - " (2030, 'TF', '01-03 02:00:00+01:00'),\n", - " (2030, 'TF', '01-03 03:00:00+01:00'),\n", - " (2030, 'TF', '01-03 04:00:00+01:00'),\n", - " (2030, 'TF', '01-03 05:00:00+01:00'),\n", - " (2030, 'TF', '01-03 06:00:00+01:00'),\n", - " (2030, 'TF', '01-03 07:00:00+01:00'),\n", - " (2030, 'TF', '01-03 08:00:00+01:00'),\n", - " (2030, 'TF', '01-03 09:00:00+01:00'),\n", - " (2030, 'TF', '01-03 10:00:00+01:00'),\n", - " (2030, 'TF', '01-03 11:00:00+01:00'),\n", - " (2030, 'TF', '01-03 12:00:00+01:00'),\n", - " (2030, 'TF', '01-03 13:00:00+01:00'),\n", - " (2030, 'TF', '01-03 14:00:00+01:00'),\n", - " (2030, 'TF', '01-03 15:00:00+01:00'),\n", - " (2030, 'TF', '01-03 16:00:00+01:00'),\n", - " (2030, 'TF', '01-03 17:00:00+01:00'),\n", - " (2030, 'TF', '01-03 18:00:00+01:00'),\n", - " (2030, 'TF', '01-03 19:00:00+01:00'),\n", - " (2030, 'TF', '01-03 20:00:00+01:00'),\n", - " (2030, 'TF', '01-03 21:00:00+01:00'),\n", - " (2030, 'TF', '01-03 22:00:00+01:00'),\n", - " (2030, 'TF', '01-03 23:00:00+01:00'),\n", - " (2030, 'TF', '01-04 00:00:00+01:00'),\n", - " (2030, 'TF', '01-04 01:00:00+01:00'),\n", - " (2030, 'TF', '01-04 02:00:00+01:00'),\n", - " (2030, 'TF', '01-04 03:00:00+01:00'),\n", - " (2030, 'TF', '01-04 04:00:00+01:00'),\n", - " (2030, 'TF', '01-04 05:00:00+01:00'),\n", - " (2030, 'TF', '01-04 06:00:00+01:00'),\n", - " (2030, 'TF', '01-04 07:00:00+01:00'),\n", - " (2030, 'TF', '01-04 08:00:00+01:00'),\n", - " (2030, 'TF', '01-04 09:00:00+01:00'),\n", - " (2030, 'TF', '01-04 10:00:00+01:00'),\n", - " (2030, 'TF', '01-04 11:00:00+01:00'),\n", - " (2030, 'TF', '01-04 12:00:00+01:00'),\n", - " (2030, 'TF', '01-04 13:00:00+01:00'),\n", - " (2030, 'TF', '01-04 14:00:00+01:00'),\n", - " (2030, 'TF', '01-04 15:00:00+01:00'),\n", - " (2030, 'TF', '01-04 16:00:00+01:00'),\n", - " (2030, 'TF', '01-04 17:00:00+01:00'),\n", - " (2030, 'TF', '01-04 18:00:00+01:00'),\n", - " (2030, 'TF', '01-04 19:00:00+01:00'),\n", - " (2030, 'TF', '01-04 20:00:00+01:00'),\n", - " (2030, 'TF', '01-04 21:00:00+01:00'),\n", - " (2030, 'TF', '01-04 22:00:00+01:00'),\n", - " (2030, 'TF', '01-04 23:00:00+01:00'),\n", - " (2030, 'TF', '01-05 00:00:00+01:00'),\n", - " (2030, 'TF', '01-05 01:00:00+01:00'),\n", - " (2030, 'TF', '01-05 02:00:00+01:00'),\n", - " (2030, 'TF', '01-05 03:00:00+01:00'),\n", - " (2030, 'TF', '01-05 04:00:00+01:00'),\n", - " (2030, 'TF', '01-05 05:00:00+01:00'),\n", - " (2030, 'TF', '01-05 06:00:00+01:00'),\n", - " (2030, 'TF', '01-05 07:00:00+01:00'),\n", - " (2030, 'TF', '01-05 08:00:00+01:00'),\n", - " (2030, 'TF', '01-05 09:00:00+01:00'),\n", - " (2030, 'TF', '01-05 10:00:00+01:00'),\n", - " (2030, 'TF', '01-05 11:00:00+01:00'),\n", - " (2030, 'TF', '01-05 12:00:00+01:00'),\n", - " (2030, 'TF', '01-05 13:00:00+01:00'),\n", - " (2030, 'TF', '01-05 14:00:00+01:00'),\n", - " (2030, 'TF', '01-05 15:00:00+01:00'),\n", - " (2030, 'TF', '01-05 16:00:00+01:00'),\n", - " (2030, 'TF', '01-05 17:00:00+01:00'),\n", - " (2030, 'TF', '01-05 18:00:00+01:00'),\n", - " (2030, 'TF', '01-05 19:00:00+01:00'),\n", - " (2030, 'TF', '01-05 20:00:00+01:00'),\n", - " (2030, 'TF', '01-05 21:00:00+01:00'),\n", - " (2030, 'TF', '01-05 22:00:00+01:00'),\n", - " (2030, 'TF', '01-05 23:00:00+01:00'),\n", - " (2030, 'TF', '01-06 00:00:00+01:00'),\n", - " (2030, 'TF', '01-06 01:00:00+01:00'),\n", - " (2030, 'TF', '01-06 02:00:00+01:00'),\n", - " (2030, 'TF', '01-06 03:00:00+01:00'),\n", - " (2030, 'TF', '01-06 04:00:00+01:00'),\n", - " (2030, 'TF', '01-06 05:00:00+01:00'),\n", - " (2030, 'TF', '01-06 06:00:00+01:00'),\n", - " (2030, 'TF', '01-06 07:00:00+01:00'),\n", - " (2030, 'TF', '01-06 08:00:00+01:00'),\n", - " (2030, 'TF', '01-06 09:00:00+01:00'),\n", - " (2030, 'TF', '01-06 10:00:00+01:00'),\n", - " (2030, 'TF', '01-06 11:00:00+01:00'),\n", - " (2030, 'TF', '01-06 12:00:00+01:00'),\n", - " (2030, 'TF', '01-06 13:00:00+01:00'),\n", - " (2030, 'TF', '01-06 14:00:00+01:00'),\n", - " (2030, 'TF', '01-06 15:00:00+01:00'),\n", - " (2030, 'TF', '01-06 16:00:00+01:00'),\n", - " (2030, 'TF', '01-06 17:00:00+01:00'),\n", - " (2030, 'TF', '01-06 18:00:00+01:00'),\n", - " (2030, 'TF', '01-06 19:00:00+01:00'),\n", - " (2030, 'TF', '01-06 20:00:00+01:00'),\n", - " (2030, 'TF', '01-06 21:00:00+01:00'),\n", - " (2030, 'TF', '01-06 22:00:00+01:00'),\n", - " (2030, 'TF', '01-06 23:00:00+01:00'),\n", - " (2030, 'TF', '01-07 00:00:00+01:00'),\n", - " (2030, 'TF', '01-07 01:00:00+01:00'),\n", - " (2030, 'TF', '01-07 02:00:00+01:00'),\n", - " (2030, 'TF', '01-07 03:00:00+01:00'),\n", - " (2030, 'TF', '01-07 04:00:00+01:00'),\n", - " (2030, 'TF', '01-07 05:00:00+01:00'),\n", - " (2030, 'TF', '01-07 06:00:00+01:00'),\n", - " (2030, 'TF', '01-07 07:00:00+01:00'),\n", - " (2030, 'TF', '01-07 08:00:00+01:00'),\n", - " (2030, 'TF', '01-07 09:00:00+01:00'),\n", - " (2030, 'TF', '01-07 10:00:00+01:00'),\n", - " (2030, 'TF', '01-07 11:00:00+01:00'),\n", - " (2030, 'TF', '01-07 12:00:00+01:00'),\n", - " (2030, 'TF', '01-07 13:00:00+01:00'),\n", - " (2030, 'TF', '01-07 14:00:00+01:00'),\n", - " (2030, 'TF', '01-07 15:00:00+01:00'),\n", - " (2030, 'TF', '01-07 16:00:00+01:00'),\n", - " (2030, 'TF', '01-07 17:00:00+01:00'),\n", - " (2030, 'TF', '01-07 18:00:00+01:00'),\n", - " (2030, 'TF', '01-07 19:00:00+01:00'),\n", - " (2030, 'TF', '01-07 20:00:00+01:00'),\n", - " (2030, 'TF', '01-07 21:00:00+01:00'),\n", - " (2030, 'TF', '01-07 22:00:00+01:00'),\n", - " (2030, 'TF', '01-07 23:00:00+01:00'),\n", - " (2030, 'TF', '01-08 00:00:00+01:00'),\n", - " (2030, 'TF', '01-08 01:00:00+01:00'),\n", - " (2030, 'TF', '01-08 02:00:00+01:00'),\n", - " (2030, 'TF', '01-08 03:00:00+01:00'),\n", - " (2030, 'TF', '01-08 04:00:00+01:00'),\n", - " (2030, 'TF', '01-08 05:00:00+01:00'),\n", - " (2030, 'TF', '01-08 06:00:00+01:00'),\n", - " (2030, 'TF', '01-08 07:00:00+01:00'),\n", - " (2030, 'TF', '01-08 08:00:00+01:00'),\n", - " (2030, 'TF', '01-08 09:00:00+01:00'),\n", - " (2030, 'TF', '01-08 10:00:00+01:00'),\n", - " (2030, 'TF', '01-08 11:00:00+01:00'),\n", - " (2030, 'TF', '01-08 12:00:00+01:00'),\n", - " (2030, 'TF', '01-08 13:00:00+01:00'),\n", - " (2030, 'TF', '01-08 14:00:00+01:00'),\n", - " (2030, 'TF', '01-08 15:00:00+01:00'),\n", - " (2030, 'TF', '01-08 16:00:00+01:00'),\n", - " (2030, 'TF', '01-08 17:00:00+01:00'),\n", - " (2030, 'TF', '01-08 18:00:00+01:00'),\n", - " (2030, 'TF', '01-08 19:00:00+01:00'),\n", - " (2030, 'TF', '01-08 20:00:00+01:00'),\n", - " (2030, 'TF', '01-08 21:00:00+01:00'),\n", - " (2030, 'TF', '01-08 22:00:00+01:00'),\n", - " (2030, 'TF', '01-08 23:00:00+01:00'),\n", - " (2030, 'TF', '01-09 00:00:00+01:00'),\n", - " (2030, 'TF', '01-09 01:00:00+01:00'),\n", - " (2030, 'TF', '01-09 02:00:00+01:00'),\n", - " (2030, 'TF', '01-09 03:00:00+01:00'),\n", - " (2030, 'TF', '01-09 04:00:00+01:00'),\n", - " (2030, 'TF', '01-09 05:00:00+01:00'),\n", - " (2030, 'TF', '01-09 06:00:00+01:00'),\n", - " (2030, 'TF', '01-09 07:00:00+01:00'),\n", - " (2030, 'TF', '01-09 08:00:00+01:00'),\n", - " (2030, 'TF', '01-09 09:00:00+01:00'),\n", - " (2030, 'TF', '01-09 10:00:00+01:00'),\n", - " (2030, 'TF', '01-09 11:00:00+01:00'),\n", - " (2030, 'TF', '01-09 12:00:00+01:00'),\n", - " (2030, 'TF', '01-09 13:00:00+01:00'),\n", - " (2030, 'TF', '01-09 14:00:00+01:00'),\n", - " (2030, 'TF', '01-09 15:00:00+01:00'),\n", - " (2030, 'TF', '01-09 16:00:00+01:00'),\n", - " (2030, 'TF', '01-09 17:00:00+01:00'),\n", - " (2030, 'TF', '01-09 18:00:00+01:00'),\n", - " (2030, 'TF', '01-09 19:00:00+01:00'),\n", - " (2030, 'TF', '01-09 20:00:00+01:00'),\n", - " (2030, 'TF', '01-09 21:00:00+01:00'),\n", - " (2030, 'TF', '01-09 22:00:00+01:00'),\n", - " (2030, 'TF', '01-09 23:00:00+01:00'),\n", - " (2030, 'TF', '01-10 00:00:00+01:00'),\n", - " (2030, 'TF', '01-10 01:00:00+01:00'),\n", - " (2030, 'TF', '01-10 02:00:00+01:00'),\n", - " (2030, 'TF', '01-10 03:00:00+01:00'),\n", - " (2030, 'TF', '01-10 04:00:00+01:00'),\n", - " (2030, 'TF', '01-10 05:00:00+01:00'),\n", - " (2030, 'TF', '01-10 06:00:00+01:00'),\n", - " (2030, 'TF', '01-10 07:00:00+01:00'),\n", - " (2030, 'TF', '01-10 08:00:00+01:00'),\n", - " (2030, 'TF', '01-10 09:00:00+01:00'),\n", - " (2030, 'TF', '01-10 10:00:00+01:00'),\n", - " (2030, 'TF', '01-10 11:00:00+01:00'),\n", - " (2030, 'TF', '01-10 12:00:00+01:00'),\n", - " (2030, 'TF', '01-10 13:00:00+01:00'),\n", - " (2030, 'TF', '01-10 14:00:00+01:00'),\n", - " (2030, 'TF', '01-10 15:00:00+01:00'),\n", - " (2030, 'TF', '01-10 16:00:00+01:00'),\n", - " (2030, 'TF', '01-10 17:00:00+01:00'),\n", - " (2030, 'TF', '01-10 18:00:00+01:00'),\n", - " (2030, 'TF', '01-10 19:00:00+01:00'),\n", - " (2030, 'TF', '01-10 20:00:00+01:00'),\n", - " (2030, 'TF', '01-10 21:00:00+01:00'),\n", - " (2030, 'TF', '01-10 22:00:00+01:00'),\n", - " (2030, 'TF', '01-10 23:00:00+01:00'),\n", - " (2030, 'TF', '01-11 00:00:00+01:00'),\n", - " (2030, 'TF', '01-11 01:00:00+01:00'),\n", - " (2030, 'TF', '01-11 02:00:00+01:00'),\n", - " (2030, 'TF', '01-11 03:00:00+01:00'),\n", - " (2030, 'TF', '01-11 04:00:00+01:00'),\n", - " (2030, 'TF', '01-11 05:00:00+01:00'),\n", - " (2030, 'TF', '01-11 06:00:00+01:00'),\n", - " (2030, 'TF', '01-11 07:00:00+01:00'),\n", - " (2030, 'TF', '01-11 08:00:00+01:00'),\n", - " (2030, 'TF', '01-11 09:00:00+01:00'),\n", - " (2030, 'TF', '01-11 10:00:00+01:00'),\n", - " (2030, 'TF', '01-11 11:00:00+01:00'),\n", - " (2030, 'TF', '01-11 12:00:00+01:00'),\n", - " (2030, 'TF', '01-11 13:00:00+01:00'),\n", - " (2030, 'TF', '01-11 14:00:00+01:00'),\n", - " (2030, 'TF', '01-11 15:00:00+01:00'),\n", - " (2030, 'TF', '01-11 16:00:00+01:00'),\n", - " (2030, 'TF', '01-11 17:00:00+01:00'),\n", - " (2030, 'TF', '01-11 18:00:00+01:00'),\n", - " (2030, 'TF', '01-11 19:00:00+01:00'),\n", - " (2030, 'TF', '01-11 20:00:00+01:00'),\n", - " (2030, 'TF', '01-11 21:00:00+01:00'),\n", - " (2030, 'TF', '01-11 22:00:00+01:00'),\n", - " (2030, 'TF', '01-11 23:00:00+01:00'),\n", - " (2030, 'TF', '01-12 00:00:00+01:00'),\n", - " (2030, 'TF', '01-12 01:00:00+01:00'),\n", - " (2030, 'TF', '01-12 02:00:00+01:00'),\n", - " (2030, 'TF', '01-12 03:00:00+01:00'),\n", - " (2030, 'TF', '01-12 04:00:00+01:00'),\n", - " (2030, 'TF', '01-12 05:00:00+01:00'),\n", - " (2030, 'TF', '01-12 06:00:00+01:00'),\n", - " (2030, 'TF', '01-12 07:00:00+01:00'),\n", - " (2030, 'TF', '01-12 08:00:00+01:00'),\n", - " (2030, 'TF', '01-12 09:00:00+01:00'),\n", - " (2030, 'TF', '01-12 10:00:00+01:00'),\n", - " (2030, 'TF', '01-12 11:00:00+01:00'),\n", - " (2030, 'TF', '01-12 12:00:00+01:00'),\n", - " (2030, 'TF', '01-12 13:00:00+01:00'),\n", - " (2030, 'TF', '01-12 14:00:00+01:00'),\n", - " (2030, 'TF', '01-12 15:00:00+01:00'),\n", - " (2030, 'TF', '01-12 16:00:00+01:00'),\n", - " (2030, 'TF', '01-12 17:00:00+01:00'),\n", - " (2030, 'TF', '01-12 18:00:00+01:00'),\n", - " (2030, 'TF', '01-12 19:00:00+01:00'),\n", - " (2030, 'TF', '01-12 20:00:00+01:00'),\n", - " (2030, 'TF', '01-12 21:00:00+01:00'),\n", - " (2030, 'TF', '01-12 22:00:00+01:00'),\n", - " (2030, 'TF', '01-12 23:00:00+01:00'),\n", - " (2030, 'TF', '01-13 00:00:00+01:00'),\n", - " (2030, 'TF', '01-13 01:00:00+01:00'),\n", - " (2030, 'TF', '01-13 02:00:00+01:00'),\n", - " (2030, 'TF', '01-13 03:00:00+01:00'),\n", - " (2030, 'TF', '01-13 04:00:00+01:00'),\n", - " (2030, 'TF', '01-13 05:00:00+01:00'),\n", - " (2030, 'TF', '01-13 06:00:00+01:00'),\n", - " (2030, 'TF', '01-13 07:00:00+01:00'),\n", - " (2030, 'TF', '01-13 08:00:00+01:00'),\n", - " (2030, 'TF', '01-13 09:00:00+01:00'),\n", - " (2030, 'TF', '01-13 10:00:00+01:00'),\n", - " (2030, 'TF', '01-13 11:00:00+01:00'),\n", - " (2030, 'TF', '01-13 12:00:00+01:00'),\n", - " (2030, 'TF', '01-13 13:00:00+01:00'),\n", - " (2030, 'TF', '01-13 14:00:00+01:00'),\n", - " (2030, 'TF', '01-13 15:00:00+01:00'),\n", - " (2030, 'TF', '01-13 16:00:00+01:00'),\n", - " (2030, 'TF', '01-13 17:00:00+01:00'),\n", - " (2030, 'TF', '01-13 18:00:00+01:00'),\n", - " (2030, 'TF', '01-13 19:00:00+01:00'),\n", - " (2030, 'TF', '01-13 20:00:00+01:00'),\n", - " (2030, 'TF', '01-13 21:00:00+01:00'),\n", - " (2030, 'TF', '01-13 22:00:00+01:00'),\n", - " (2030, 'TF', '01-13 23:00:00+01:00'),\n", - " (2030, 'TF', '01-14 00:00:00+01:00'),\n", - " (2030, 'TF', '01-14 01:00:00+01:00'),\n", - " (2030, 'TF', '01-14 02:00:00+01:00'),\n", - " (2030, 'TF', '01-14 03:00:00+01:00'),\n", - " (2030, 'TF', '01-14 04:00:00+01:00'),\n", - " (2030, 'TF', '01-14 05:00:00+01:00'),\n", - " (2030, 'TF', '01-14 06:00:00+01:00'),\n", - " (2030, 'TF', '01-14 07:00:00+01:00'),\n", - " (2030, 'TF', '01-14 08:00:00+01:00'),\n", - " (2030, 'TF', '01-14 09:00:00+01:00'),\n", - " (2030, 'TF', '01-14 10:00:00+01:00'),\n", - " (2030, 'TF', '01-14 11:00:00+01:00'),\n", - " (2030, 'TF', '01-14 12:00:00+01:00'),\n", - " (2030, 'TF', '01-14 13:00:00+01:00'),\n", - " (2030, 'TF', '01-14 14:00:00+01:00'),\n", - " (2030, 'TF', '01-14 15:00:00+01:00'),\n", - " (2030, 'TF', '01-14 16:00:00+01:00'),\n", - " (2030, 'TF', '01-14 17:00:00+01:00'),\n", - " (2030, 'TF', '01-14 18:00:00+01:00'),\n", - " (2030, 'TF', '01-14 19:00:00+01:00'),\n", - " (2030, 'TF', '01-14 20:00:00+01:00'),\n", - " (2030, 'TF', '01-14 21:00:00+01:00'),\n", - " (2030, 'TF', '01-14 22:00:00+01:00'),\n", - " (2030, 'TF', '01-14 23:00:00+01:00'),\n", - " (2030, 'TF', '01-15 00:00:00+01:00'),\n", - " (2030, 'TF', '01-15 01:00:00+01:00'),\n", - " (2030, 'TF', '01-15 02:00:00+01:00'),\n", - " (2030, 'TF', '01-15 03:00:00+01:00'),\n", - " (2030, 'TF', '01-15 04:00:00+01:00'),\n", - " (2030, 'TF', '01-15 05:00:00+01:00'),\n", - " (2030, 'TF', '01-15 06:00:00+01:00'),\n", - " (2030, 'TF', '01-15 07:00:00+01:00'),\n", - " (2030, 'TF', '01-15 08:00:00+01:00'),\n", - " (2030, 'TF', '01-15 09:00:00+01:00'),\n", - " (2030, 'TF', '01-15 10:00:00+01:00'),\n", - " (2030, 'TF', '01-15 11:00:00+01:00'),\n", - " (2030, 'TF', '01-15 12:00:00+01:00'),\n", - " (2030, 'TF', '01-15 13:00:00+01:00'),\n", - " (2030, 'TF', '01-15 14:00:00+01:00'),\n", - " (2030, 'TF', '01-15 15:00:00+01:00'),\n", - " (2030, 'TF', '01-15 16:00:00+01:00'),\n", - " (2030, 'TF', '01-15 17:00:00+01:00'),\n", - " (2030, 'TF', '01-15 18:00:00+01:00'),\n", - " (2030, 'TF', '01-15 19:00:00+01:00'),\n", - " (2030, 'TF', '01-15 20:00:00+01:00'),\n", - " (2030, 'TF', '01-15 21:00:00+01:00'),\n", - " (2030, 'TF', '01-15 22:00:00+01:00'),\n", - " (2030, 'TF', '01-15 23:00:00+01:00'),\n", - " (2030, 'TF', '01-16 00:00:00+01:00'),\n", - " (2030, 'TF', '01-16 01:00:00+01:00'),\n", - " (2030, 'TF', '01-16 02:00:00+01:00'),\n", - " (2030, 'TF', '01-16 03:00:00+01:00'),\n", - " (2030, 'TF', '01-16 04:00:00+01:00'),\n", - " (2030, 'TF', '01-16 05:00:00+01:00'),\n", - " (2030, 'TF', '01-16 06:00:00+01:00'),\n", - " (2030, 'TF', '01-16 07:00:00+01:00'),\n", - " (2030, 'TF', '01-16 08:00:00+01:00'),\n", - " (2030, 'TF', '01-16 09:00:00+01:00'),\n", - " (2030, 'TF', '01-16 10:00:00+01:00'),\n", - " (2030, 'TF', '01-16 11:00:00+01:00'),\n", - " (2030, 'TF', '01-16 12:00:00+01:00'),\n", - " (2030, 'TF', '01-16 13:00:00+01:00'),\n", - " (2030, 'TF', '01-16 14:00:00+01:00'),\n", - " (2030, 'TF', '01-16 15:00:00+01:00'),\n", - " (2030, 'TF', '01-16 16:00:00+01:00'),\n", - " (2030, 'TF', '01-16 17:00:00+01:00'),\n", - " (2030, 'TF', '01-16 18:00:00+01:00'),\n", - " (2030, 'TF', '01-16 19:00:00+01:00'),\n", - " (2030, 'TF', '01-16 20:00:00+01:00'),\n", - " (2030, 'TF', '01-16 21:00:00+01:00'),\n", - " (2030, 'TF', '01-16 22:00:00+01:00'),\n", - " (2030, 'TF', '01-16 23:00:00+01:00'),\n", - " (2030, 'TF', '01-17 00:00:00+01:00'),\n", - " (2030, 'TF', '01-17 01:00:00+01:00'),\n", - " (2030, 'TF', '01-17 02:00:00+01:00'),\n", - " (2030, 'TF', '01-17 03:00:00+01:00'),\n", - " (2030, 'TF', '01-17 04:00:00+01:00'),\n", - " (2030, 'TF', '01-17 05:00:00+01:00'),\n", - " (2030, 'TF', '01-17 06:00:00+01:00'),\n", - " (2030, 'TF', '01-17 07:00:00+01:00'),\n", - " (2030, 'TF', '01-17 08:00:00+01:00'),\n", - " (2030, 'TF', '01-17 09:00:00+01:00'),\n", - " (2030, 'TF', '01-17 10:00:00+01:00'),\n", - " (2030, 'TF', '01-17 11:00:00+01:00'),\n", - " (2030, 'TF', '01-17 12:00:00+01:00'),\n", - " (2030, 'TF', '01-17 13:00:00+01:00'),\n", - " (2030, 'TF', '01-17 14:00:00+01:00'),\n", - " (2030, 'TF', '01-17 15:00:00+01:00'),\n", - " (2030, 'TF', '01-17 16:00:00+01:00'),\n", - " (2030, 'TF', '01-17 17:00:00+01:00'),\n", - " (2030, 'TF', '01-17 18:00:00+01:00'),\n", - " (2030, 'TF', '01-17 19:00:00+01:00'),\n", - " (2030, 'TF', '01-17 20:00:00+01:00'),\n", - " (2030, 'TF', '01-17 21:00:00+01:00'),\n", - " (2030, 'TF', '01-17 22:00:00+01:00'),\n", - " (2030, 'TF', '01-17 23:00:00+01:00'),\n", - " (2030, 'TF', '01-18 00:00:00+01:00'),\n", - " (2030, 'TF', '01-18 01:00:00+01:00'),\n", - " (2030, 'TF', '01-18 02:00:00+01:00'),\n", - " (2030, 'TF', '01-18 03:00:00+01:00'),\n", - " (2030, 'TF', '01-18 04:00:00+01:00'),\n", - " (2030, 'TF', '01-18 05:00:00+01:00'),\n", - " (2030, 'TF', '01-18 06:00:00+01:00'),\n", - " (2030, 'TF', '01-18 07:00:00+01:00'),\n", - " (2030, 'TF', '01-18 08:00:00+01:00'),\n", - " (2030, 'TF', '01-18 09:00:00+01:00'),\n", - " (2030, 'TF', '01-18 10:00:00+01:00'),\n", - " (2030, 'TF', '01-18 11:00:00+01:00'),\n", - " (2030, 'TF', '01-18 12:00:00+01:00'),\n", - " (2030, 'TF', '01-18 13:00:00+01:00'),\n", - " (2030, 'TF', '01-18 14:00:00+01:00'),\n", - " (2030, 'TF', '01-18 15:00:00+01:00'),\n", - " (2030, 'TF', '01-18 16:00:00+01:00'),\n", - " (2030, 'TF', '01-18 17:00:00+01:00'),\n", - " (2030, 'TF', '01-18 18:00:00+01:00'),\n", - " (2030, 'TF', '01-18 19:00:00+01:00'),\n", - " (2030, 'TF', '01-18 20:00:00+01:00'),\n", - " (2030, 'TF', '01-18 21:00:00+01:00'),\n", - " (2030, 'TF', '01-18 22:00:00+01:00'),\n", - " (2030, 'TF', '01-18 23:00:00+01:00'),\n", - " (2030, 'TF', '01-19 00:00:00+01:00'),\n", - " (2030, 'TF', '01-19 01:00:00+01:00'),\n", - " (2030, 'TF', '01-19 02:00:00+01:00'),\n", - " (2030, 'TF', '01-19 03:00:00+01:00'),\n", - " (2030, 'TF', '01-19 04:00:00+01:00'),\n", - " (2030, 'TF', '01-19 05:00:00+01:00'),\n", - " (2030, 'TF', '01-19 06:00:00+01:00'),\n", - " (2030, 'TF', '01-19 07:00:00+01:00'),\n", - " (2030, 'TF', '01-19 08:00:00+01:00'),\n", - " (2030, 'TF', '01-19 09:00:00+01:00'),\n", - " (2030, 'TF', '01-19 10:00:00+01:00'),\n", - " (2030, 'TF', '01-19 11:00:00+01:00'),\n", - " (2030, 'TF', '01-19 12:00:00+01:00'),\n", - " (2030, 'TF', '01-19 13:00:00+01:00'),\n", - " (2030, 'TF', '01-19 14:00:00+01:00'),\n", - " (2030, 'TF', '01-19 15:00:00+01:00'),\n", - " (2030, 'TF', '01-19 16:00:00+01:00'),\n", - " (2030, 'TF', '01-19 17:00:00+01:00'),\n", - " (2030, 'TF', '01-19 18:00:00+01:00'),\n", - " (2030, 'TF', '01-19 19:00:00+01:00'),\n", - " (2030, 'TF', '01-19 20:00:00+01:00'),\n", - " (2030, 'TF', '01-19 21:00:00+01:00'),\n", - " (2030, 'TF', '01-19 22:00:00+01:00'),\n", - " (2030, 'TF', '01-19 23:00:00+01:00'),\n", - " (2030, 'TF', '01-20 00:00:00+01:00'),\n", - " (2030, 'TF', '01-20 01:00:00+01:00'),\n", - " (2030, 'TF', '01-20 02:00:00+01:00'),\n", - " (2030, 'TF', '01-20 03:00:00+01:00'),\n", - " (2030, 'TF', '01-20 04:00:00+01:00'),\n", - " (2030, 'TF', '01-20 05:00:00+01:00'),\n", - " (2030, 'TF', '01-20 06:00:00+01:00'),\n", - " (2030, 'TF', '01-20 07:00:00+01:00'),\n", - " (2030, 'TF', '01-20 08:00:00+01:00'),\n", - " (2030, 'TF', '01-20 09:00:00+01:00'),\n", - " (2030, 'TF', '01-20 10:00:00+01:00'),\n", - " (2030, 'TF', '01-20 11:00:00+01:00'),\n", - " (2030, 'TF', '01-20 12:00:00+01:00'),\n", - " (2030, 'TF', '01-20 13:00:00+01:00'),\n", - " (2030, 'TF', '01-20 14:00:00+01:00'),\n", - " (2030, 'TF', '01-20 15:00:00+01:00'),\n", - " (2030, 'TF', '01-20 16:00:00+01:00'),\n", - " (2030, 'TF', '01-20 17:00:00+01:00'),\n", - " (2030, 'TF', '01-20 18:00:00+01:00'),\n", - " (2030, 'TF', '01-20 19:00:00+01:00'),\n", - " (2030, 'TF', '01-20 20:00:00+01:00'),\n", - " (2030, 'TF', '01-20 21:00:00+01:00'),\n", - " (2030, 'TF', '01-20 22:00:00+01:00'),\n", - " (2030, 'TF', '01-20 23:00:00+01:00'),\n", - " (2030, 'TF', '01-21 00:00:00+01:00'),\n", - " (2030, 'TF', '01-21 01:00:00+01:00'),\n", - " (2030, 'TF', '01-21 02:00:00+01:00'),\n", - " (2030, 'TF', '01-21 03:00:00+01:00'),\n", - " (2030, 'TF', '01-21 04:00:00+01:00'),\n", - " (2030, 'TF', '01-21 05:00:00+01:00'),\n", - " (2030, 'TF', '01-21 06:00:00+01:00'),\n", - " (2030, 'TF', '01-21 07:00:00+01:00'),\n", - " (2030, 'TF', '01-21 08:00:00+01:00'),\n", - " (2030, 'TF', '01-21 09:00:00+01:00'),\n", - " (2030, 'TF', '01-21 10:00:00+01:00'),\n", - " (2030, 'TF', '01-21 11:00:00+01:00'),\n", - " (2030, 'TF', '01-21 12:00:00+01:00'),\n", - " (2030, 'TF', '01-21 13:00:00+01:00'),\n", - " (2030, 'TF', '01-21 14:00:00+01:00'),\n", - " (2030, 'TF', '01-21 15:00:00+01:00'),\n", - " (2030, 'TF', '01-21 16:00:00+01:00'),\n", - " (2030, 'TF', '01-21 17:00:00+01:00'),\n", - " (2030, 'TF', '01-21 18:00:00+01:00'),\n", - " (2030, 'TF', '01-21 19:00:00+01:00'),\n", - " (2030, 'TF', '01-21 20:00:00+01:00'),\n", - " (2030, 'TF', '01-21 21:00:00+01:00'),\n", - " (2030, 'TF', '01-21 22:00:00+01:00'),\n", - " (2030, 'TF', '01-21 23:00:00+01:00'),\n", - " (2030, 'TF', '01-22 00:00:00+01:00'),\n", - " (2030, 'TF', '01-22 01:00:00+01:00'),\n", - " (2030, 'TF', '01-22 02:00:00+01:00'),\n", - " (2030, 'TF', '01-22 03:00:00+01:00'),\n", - " (2030, 'TF', '01-22 04:00:00+01:00'),\n", - " (2030, 'TF', '01-22 05:00:00+01:00'),\n", - " (2030, 'TF', '01-22 06:00:00+01:00'),\n", - " (2030, 'TF', '01-22 07:00:00+01:00'),\n", - " (2030, 'TF', '01-22 08:00:00+01:00'),\n", - " (2030, 'TF', '01-22 09:00:00+01:00'),\n", - " (2030, 'TF', '01-22 10:00:00+01:00'),\n", - " (2030, 'TF', '01-22 11:00:00+01:00'),\n", - " (2030, 'TF', '01-22 12:00:00+01:00'),\n", - " (2030, 'TF', '01-22 13:00:00+01:00'),\n", - " (2030, 'TF', '01-22 14:00:00+01:00'),\n", - " (2030, 'TF', '01-22 15:00:00+01:00'),\n", - " (2030, 'TF', '01-22 16:00:00+01:00'),\n", - " (2030, 'TF', '01-22 17:00:00+01:00'),\n", - " (2030, 'TF', '01-22 18:00:00+01:00'),\n", - " (2030, 'TF', '01-22 19:00:00+01:00'),\n", - " (2030, 'TF', '01-22 20:00:00+01:00'),\n", - " (2030, 'TF', '01-22 21:00:00+01:00'),\n", - " (2030, 'TF', '01-22 22:00:00+01:00'),\n", - " (2030, 'TF', '01-22 23:00:00+01:00'),\n", - " (2030, 'TF', '01-23 00:00:00+01:00'),\n", - " (2030, 'TF', '01-23 01:00:00+01:00'),\n", - " (2030, 'TF', '01-23 02:00:00+01:00'),\n", - " (2030, 'TF', '01-23 03:00:00+01:00'),\n", - " (2030, 'TF', '01-23 04:00:00+01:00'),\n", - " (2030, 'TF', '01-23 05:00:00+01:00'),\n", - " (2030, 'TF', '01-23 06:00:00+01:00'),\n", - " (2030, 'TF', '01-23 07:00:00+01:00'),\n", - " (2030, 'TF', '01-23 08:00:00+01:00'),\n", - " (2030, 'TF', '01-23 09:00:00+01:00'),\n", - " (2030, 'TF', '01-23 10:00:00+01:00'),\n", - " (2030, 'TF', '01-23 11:00:00+01:00'),\n", - " (2030, 'TF', '01-23 12:00:00+01:00'),\n", - " (2030, 'TF', '01-23 13:00:00+01:00'),\n", - " (2030, 'TF', '01-23 14:00:00+01:00'),\n", - " (2030, 'TF', '01-23 15:00:00+01:00'),\n", - " (2030, 'TF', '01-23 16:00:00+01:00'),\n", - " (2030, 'TF', '01-23 17:00:00+01:00'),\n", - " (2030, 'TF', '01-23 18:00:00+01:00'),\n", - " (2030, 'TF', '01-23 19:00:00+01:00'),\n", - " (2030, 'TF', '01-23 20:00:00+01:00'),\n", - " (2030, 'TF', '01-23 21:00:00+01:00'),\n", - " (2030, 'TF', '01-23 22:00:00+01:00'),\n", - " (2030, 'TF', '01-23 23:00:00+01:00'),\n", - " (2030, 'TF', '01-24 00:00:00+01:00'),\n", - " (2030, 'TF', '01-24 01:00:00+01:00'),\n", - " (2030, 'TF', '01-24 02:00:00+01:00'),\n", - " (2030, 'TF', '01-24 03:00:00+01:00'),\n", - " (2030, 'TF', '01-24 04:00:00+01:00'),\n", - " (2030, 'TF', '01-24 05:00:00+01:00'),\n", - " (2030, 'TF', '01-24 06:00:00+01:00'),\n", - " (2030, 'TF', '01-24 07:00:00+01:00'),\n", - " (2030, 'TF', '01-24 08:00:00+01:00'),\n", - " (2030, 'TF', '01-24 09:00:00+01:00'),\n", - " (2030, 'TF', '01-24 10:00:00+01:00'),\n", - " (2030, 'TF', '01-24 11:00:00+01:00'),\n", - " (2030, 'TF', '01-24 12:00:00+01:00'),\n", - " (2030, 'TF', '01-24 13:00:00+01:00'),\n", - " (2030, 'TF', '01-24 14:00:00+01:00'),\n", - " (2030, 'TF', '01-24 15:00:00+01:00'),\n", - " (2030, 'TF', '01-24 16:00:00+01:00'),\n", - " (2030, 'TF', '01-24 17:00:00+01:00'),\n", - " (2030, 'TF', '01-24 18:00:00+01:00'),\n", - " (2030, 'TF', '01-24 19:00:00+01:00'),\n", - " (2030, 'TF', '01-24 20:00:00+01:00'),\n", - " (2030, 'TF', '01-24 21:00:00+01:00'),\n", - " (2030, 'TF', '01-24 22:00:00+01:00'),\n", - " (2030, 'TF', '01-24 23:00:00+01:00'),\n", - " (2030, 'TF', '01-25 00:00:00+01:00'),\n", - " (2030, 'TF', '01-25 01:00:00+01:00'),\n", - " (2030, 'TF', '01-25 02:00:00+01:00'),\n", - " (2030, 'TF', '01-25 03:00:00+01:00'),\n", - " (2030, 'TF', '01-25 04:00:00+01:00'),\n", - " (2030, 'TF', '01-25 05:00:00+01:00'),\n", - " (2030, 'TF', '01-25 06:00:00+01:00'),\n", - " (2030, 'TF', '01-25 07:00:00+01:00'),\n", - " (2030, 'TF', '01-25 08:00:00+01:00'),\n", - " (2030, 'TF', '01-25 09:00:00+01:00'),\n", - " (2030, 'TF', '01-25 10:00:00+01:00'),\n", - " (2030, 'TF', '01-25 11:00:00+01:00'),\n", - " (2030, 'TF', '01-25 12:00:00+01:00'),\n", - " (2030, 'TF', '01-25 13:00:00+01:00'),\n", - " (2030, 'TF', '01-25 14:00:00+01:00'),\n", - " (2030, 'TF', '01-25 15:00:00+01:00'),\n", - " (2030, 'TF', '01-25 16:00:00+01:00'),\n", - " (2030, 'TF', '01-25 17:00:00+01:00'),\n", - " (2030, 'TF', '01-25 18:00:00+01:00'),\n", - " (2030, 'TF', '01-25 19:00:00+01:00'),\n", - " (2030, 'TF', '01-25 20:00:00+01:00'),\n", - " (2030, 'TF', '01-25 21:00:00+01:00'),\n", - " (2030, 'TF', '01-25 22:00:00+01:00'),\n", - " (2030, 'TF', '01-25 23:00:00+01:00'),\n", - " (2030, 'TF', '01-26 00:00:00+01:00'),\n", - " (2030, 'TF', '01-26 01:00:00+01:00'),\n", - " (2030, 'TF', '01-26 02:00:00+01:00'),\n", - " (2030, 'TF', '01-26 03:00:00+01:00'),\n", - " (2030, 'TF', '01-26 04:00:00+01:00'),\n", - " (2030, 'TF', '01-26 05:00:00+01:00'),\n", - " (2030, 'TF', '01-26 06:00:00+01:00'),\n", - " (2030, 'TF', '01-26 07:00:00+01:00'),\n", - " (2030, 'TF', '01-26 08:00:00+01:00'),\n", - " (2030, 'TF', '01-26 09:00:00+01:00'),\n", - " (2030, 'TF', '01-26 10:00:00+01:00'),\n", - " (2030, 'TF', '01-26 11:00:00+01:00'),\n", - " (2030, 'TF', '01-26 12:00:00+01:00'),\n", - " (2030, 'TF', '01-26 13:00:00+01:00'),\n", - " (2030, 'TF', '01-26 14:00:00+01:00'),\n", - " (2030, 'TF', '01-26 15:00:00+01:00'),\n", - " (2030, 'TF', '01-26 16:00:00+01:00'),\n", - " (2030, 'TF', '01-26 17:00:00+01:00'),\n", - " (2030, 'TF', '01-26 18:00:00+01:00'),\n", - " (2030, 'TF', '01-26 19:00:00+01:00'),\n", - " (2030, 'TF', '01-26 20:00:00+01:00'),\n", - " (2030, 'TF', '01-26 21:00:00+01:00'),\n", - " (2030, 'TF', '01-26 22:00:00+01:00'),\n", - " (2030, 'TF', '01-26 23:00:00+01:00'),\n", - " (2030, 'TF', '01-27 00:00:00+01:00'),\n", - " (2030, 'TF', '01-27 01:00:00+01:00'),\n", - " (2030, 'TF', '01-27 02:00:00+01:00'),\n", - " (2030, 'TF', '01-27 03:00:00+01:00'),\n", - " (2030, 'TF', '01-27 04:00:00+01:00'),\n", - " (2030, 'TF', '01-27 05:00:00+01:00'),\n", - " (2030, 'TF', '01-27 06:00:00+01:00'),\n", - " (2030, 'TF', '01-27 07:00:00+01:00'),\n", - " (2030, 'TF', '01-27 08:00:00+01:00'),\n", - " (2030, 'TF', '01-27 09:00:00+01:00'),\n", - " (2030, 'TF', '01-27 10:00:00+01:00'),\n", - " (2030, 'TF', '01-27 11:00:00+01:00'),\n", - " (2030, 'TF', '01-27 12:00:00+01:00'),\n", - " (2030, 'TF', '01-27 13:00:00+01:00'),\n", - " (2030, 'TF', '01-27 14:00:00+01:00'),\n", - " (2030, 'TF', '01-27 15:00:00+01:00'),\n", - " (2030, 'TF', '01-27 16:00:00+01:00'),\n", - " (2030, 'TF', '01-27 17:00:00+01:00'),\n", - " (2030, 'TF', '01-27 18:00:00+01:00'),\n", - " (2030, 'TF', '01-27 19:00:00+01:00'),\n", - " (2030, 'TF', '01-27 20:00:00+01:00'),\n", - " (2030, 'TF', '01-27 21:00:00+01:00'),\n", - " (2030, 'TF', '01-27 22:00:00+01:00'),\n", - " (2030, 'TF', '01-27 23:00:00+01:00'),\n", - " (2030, 'TF', '01-28 00:00:00+01:00'),\n", - " (2030, 'TF', '01-28 01:00:00+01:00'),\n", - " (2030, 'TF', '01-28 02:00:00+01:00'),\n", - " (2030, 'TF', '01-28 03:00:00+01:00'),\n", - " (2030, 'TF', '01-28 04:00:00+01:00'),\n", - " (2030, 'TF', '01-28 05:00:00+01:00'),\n", - " (2030, 'TF', '01-28 06:00:00+01:00'),\n", - " (2030, 'TF', '01-28 07:00:00+01:00'),\n", - " (2030, 'TF', '01-28 08:00:00+01:00'),\n", - " (2030, 'TF', '01-28 09:00:00+01:00'),\n", - " (2030, 'TF', '01-28 10:00:00+01:00'),\n", - " (2030, 'TF', '01-28 11:00:00+01:00'),\n", - " (2030, 'TF', '01-28 12:00:00+01:00'),\n", - " (2030, 'TF', '01-28 13:00:00+01:00'),\n", - " (2030, 'TF', '01-28 14:00:00+01:00'),\n", - " (2030, 'TF', '01-28 15:00:00+01:00'),\n", - " (2030, 'TF', '01-28 16:00:00+01:00'),\n", - " (2030, 'TF', '01-28 17:00:00+01:00'),\n", - " (2030, 'TF', '01-28 18:00:00+01:00'),\n", - " (2030, 'TF', '01-28 19:00:00+01:00'),\n", - " (2030, 'TF', '01-28 20:00:00+01:00'),\n", - " (2030, 'TF', '01-28 21:00:00+01:00'),\n", - " (2030, 'TF', '01-28 22:00:00+01:00'),\n", - " (2030, 'TF', '01-28 23:00:00+01:00'),\n", - " (2030, 'TF', '01-29 00:00:00+01:00'),\n", - " (2030, 'TF', '01-29 01:00:00+01:00'),\n", - " (2030, 'TF', '01-29 02:00:00+01:00'),\n", - " (2030, 'TF', '01-29 03:00:00+01:00'),\n", - " (2030, 'TF', '01-29 04:00:00+01:00'),\n", - " (2030, 'TF', '01-29 05:00:00+01:00'),\n", - " (2030, 'TF', '01-29 06:00:00+01:00'),\n", - " (2030, 'TF', '01-29 07:00:00+01:00'),\n", - " (2030, 'TF', '01-29 08:00:00+01:00'),\n", - " (2030, 'TF', '01-29 09:00:00+01:00'),\n", - " (2030, 'TF', '01-29 10:00:00+01:00'),\n", - " (2030, 'TF', '01-29 11:00:00+01:00'),\n", - " (2030, 'TF', '01-29 12:00:00+01:00'),\n", - " (2030, 'TF', '01-29 13:00:00+01:00'),\n", - " (2030, 'TF', '01-29 14:00:00+01:00'),\n", - " (2030, 'TF', '01-29 15:00:00+01:00'),\n", - " (2030, 'TF', '01-29 16:00:00+01:00'),\n", - " (2030, 'TF', '01-29 17:00:00+01:00'),\n", - " (2030, 'TF', '01-29 18:00:00+01:00'),\n", - " (2030, 'TF', '01-29 19:00:00+01:00'),\n", - " (2030, 'TF', '01-29 20:00:00+01:00'),\n", - " (2030, 'TF', '01-29 21:00:00+01:00'),\n", - " (2030, 'TF', '01-29 22:00:00+01:00'),\n", - " (2030, 'TF', '01-29 23:00:00+01:00'),\n", - " (2030, 'TF', '01-30 00:00:00+01:00'),\n", - " (2030, 'TF', '01-30 01:00:00+01:00'),\n", - " (2030, 'TF', '01-30 02:00:00+01:00'),\n", - " (2030, 'TF', '01-30 03:00:00+01:00'),\n", - " (2030, 'TF', '01-30 04:00:00+01:00'),\n", - " (2030, 'TF', '01-30 05:00:00+01:00'),\n", - " (2030, 'TF', '01-30 06:00:00+01:00'),\n", - " (2030, 'TF', '01-30 07:00:00+01:00'),\n", - " (2030, 'TF', '01-30 08:00:00+01:00'),\n", - " (2030, 'TF', '01-30 09:00:00+01:00'),\n", - " (2030, 'TF', '01-30 10:00:00+01:00'),\n", - " (2030, 'TF', '01-30 11:00:00+01:00'),\n", - " (2030, 'TF', '01-30 12:00:00+01:00'),\n", - " (2030, 'TF', '01-30 13:00:00+01:00'),\n", - " (2030, 'TF', '01-30 14:00:00+01:00'),\n", - " (2030, 'TF', '01-30 15:00:00+01:00'),\n", - " (2030, 'TF', '01-30 16:00:00+01:00'),\n", - " (2030, 'TF', '01-30 17:00:00+01:00'),\n", - " (2030, 'TF', '01-30 18:00:00+01:00'),\n", - " (2030, 'TF', '01-30 19:00:00+01:00'),\n", - " (2030, 'TF', '01-30 20:00:00+01:00'),\n", - " (2030, 'TF', '01-30 21:00:00+01:00'),\n", - " (2030, 'TF', '01-30 22:00:00+01:00'),\n", - " (2030, 'TF', '01-30 23:00:00+01:00'),\n", - " (2030, 'TF', '01-31 00:00:00+01:00'),\n", - " (2030, 'TF', '01-31 01:00:00+01:00'),\n", - " (2030, 'TF', '01-31 02:00:00+01:00'),\n", - " (2030, 'TF', '01-31 03:00:00+01:00'),\n", - " (2030, 'TF', '01-31 04:00:00+01:00'),\n", - " (2030, 'TF', '01-31 05:00:00+01:00'),\n", - " (2030, 'TF', '01-31 06:00:00+01:00'),\n", - " (2030, 'TF', '01-31 07:00:00+01:00'),\n", - " (2030, 'TF', '01-31 08:00:00+01:00'),\n", - " (2030, 'TF', '01-31 09:00:00+01:00'),\n", - " (2030, 'TF', '01-31 10:00:00+01:00'),\n", - " (2030, 'TF', '01-31 11:00:00+01:00'),\n", - " (2030, 'TF', '01-31 12:00:00+01:00'),\n", - " (2030, 'TF', '01-31 13:00:00+01:00'),\n", - " (2030, 'TF', '01-31 14:00:00+01:00'),\n", - " (2030, 'TF', '01-31 15:00:00+01:00'),\n", - " (2030, 'TF', '01-31 16:00:00+01:00'),\n", - " (2030, 'TF', '01-31 17:00:00+01:00'),\n", - " (2030, 'TF', '01-31 18:00:00+01:00'),\n", - " (2030, 'TF', '01-31 19:00:00+01:00'),\n", - " (2030, 'TF', '01-31 20:00:00+01:00'),\n", - " (2030, 'TF', '01-31 21:00:00+01:00'),\n", - " (2030, 'TF', '01-31 22:00:00+01:00'),\n", - " (2030, 'TF', '01-31 23:00:00+01:00'),\n", - " (2030, 'TF', '02-01 00:00:00+01:00'),\n", - " (2030, 'TF', '02-01 01:00:00+01:00'),\n", - " (2030, 'TF', '02-01 02:00:00+01:00'),\n", - " (2030, 'TF', '02-01 03:00:00+01:00'),\n", - " (2030, 'TF', '02-01 04:00:00+01:00'),\n", - " (2030, 'TF', '02-01 05:00:00+01:00'),\n", - " (2030, 'TF', '02-01 06:00:00+01:00'),\n", - " (2030, 'TF', '02-01 07:00:00+01:00'),\n", - " (2030, 'TF', '02-01 08:00:00+01:00'),\n", - " (2030, 'TF', '02-01 09:00:00+01:00'),\n", - " (2030, 'TF', '02-01 10:00:00+01:00'),\n", - " (2030, 'TF', '02-01 11:00:00+01:00'),\n", - " (2030, 'TF', '02-01 12:00:00+01:00'),\n", - " (2030, 'TF', '02-01 13:00:00+01:00'),\n", - " (2030, 'TF', '02-01 14:00:00+01:00'),\n", - " (2030, 'TF', '02-01 15:00:00+01:00'),\n", - " (2030, 'TF', '02-01 16:00:00+01:00'),\n", - " (2030, 'TF', '02-01 17:00:00+01:00'),\n", - " (2030, 'TF', '02-01 18:00:00+01:00'),\n", - " (2030, 'TF', '02-01 19:00:00+01:00'),\n", - " (2030, 'TF', '02-01 20:00:00+01:00'),\n", - " (2030, 'TF', '02-01 21:00:00+01:00'),\n", - " (2030, 'TF', '02-01 22:00:00+01:00'),\n", - " (2030, 'TF', '02-01 23:00:00+01:00'),\n", - " (2030, 'TF', '02-02 00:00:00+01:00'),\n", - " (2030, 'TF', '02-02 01:00:00+01:00'),\n", - " (2030, 'TF', '02-02 02:00:00+01:00'),\n", - " (2030, 'TF', '02-02 03:00:00+01:00'),\n", - " (2030, 'TF', '02-02 04:00:00+01:00'),\n", - " (2030, 'TF', '02-02 05:00:00+01:00'),\n", - " (2030, 'TF', '02-02 06:00:00+01:00'),\n", - " (2030, 'TF', '02-02 07:00:00+01:00'),\n", - " (2030, 'TF', '02-02 08:00:00+01:00'),\n", - " (2030, 'TF', '02-02 09:00:00+01:00'),\n", - " (2030, 'TF', '02-02 10:00:00+01:00'),\n", - " (2030, 'TF', '02-02 11:00:00+01:00'),\n", - " (2030, 'TF', '02-02 12:00:00+01:00'),\n", - " (2030, 'TF', '02-02 13:00:00+01:00'),\n", - " (2030, 'TF', '02-02 14:00:00+01:00'),\n", - " (2030, 'TF', '02-02 15:00:00+01:00'),\n", - " (2030, 'TF', '02-02 16:00:00+01:00'),\n", - " (2030, 'TF', '02-02 17:00:00+01:00'),\n", - " (2030, 'TF', '02-02 18:00:00+01:00'),\n", - " (2030, 'TF', '02-02 19:00:00+01:00'),\n", - " (2030, 'TF', '02-02 20:00:00+01:00'),\n", - " (2030, 'TF', '02-02 21:00:00+01:00'),\n", - " (2030, 'TF', '02-02 22:00:00+01:00'),\n", - " (2030, 'TF', '02-02 23:00:00+01:00'),\n", - " (2030, 'TF', '02-03 00:00:00+01:00'),\n", - " (2030, 'TF', '02-03 01:00:00+01:00'),\n", - " (2030, 'TF', '02-03 02:00:00+01:00'),\n", - " (2030, 'TF', '02-03 03:00:00+01:00'),\n", - " (2030, 'TF', '02-03 04:00:00+01:00'),\n", - " (2030, 'TF', '02-03 05:00:00+01:00'),\n", - " (2030, 'TF', '02-03 06:00:00+01:00'),\n", - " (2030, 'TF', '02-03 07:00:00+01:00'),\n", - " (2030, 'TF', '02-03 08:00:00+01:00'),\n", - " (2030, 'TF', '02-03 09:00:00+01:00'),\n", - " (2030, 'TF', '02-03 10:00:00+01:00'),\n", - " (2030, 'TF', '02-03 11:00:00+01:00'),\n", - " (2030, 'TF', '02-03 12:00:00+01:00'),\n", - " (2030, 'TF', '02-03 13:00:00+01:00'),\n", - " (2030, 'TF', '02-03 14:00:00+01:00'),\n", - " (2030, 'TF', '02-03 15:00:00+01:00'),\n", - " (2030, 'TF', '02-03 16:00:00+01:00'),\n", - " (2030, 'TF', '02-03 17:00:00+01:00'),\n", - " (2030, 'TF', '02-03 18:00:00+01:00'),\n", - " (2030, 'TF', '02-03 19:00:00+01:00'),\n", - " (2030, 'TF', '02-03 20:00:00+01:00'),\n", - " (2030, 'TF', '02-03 21:00:00+01:00'),\n", - " (2030, 'TF', '02-03 22:00:00+01:00'),\n", - " (2030, 'TF', '02-03 23:00:00+01:00'),\n", - " (2030, 'TF', '02-04 00:00:00+01:00'),\n", - " (2030, 'TF', '02-04 01:00:00+01:00'),\n", - " (2030, 'TF', '02-04 02:00:00+01:00'),\n", - " (2030, 'TF', '02-04 03:00:00+01:00'),\n", - " (2030, 'TF', '02-04 04:00:00+01:00'),\n", - " (2030, 'TF', '02-04 05:00:00+01:00'),\n", - " (2030, 'TF', '02-04 06:00:00+01:00'),\n", - " (2030, 'TF', '02-04 07:00:00+01:00'),\n", - " (2030, 'TF', '02-04 08:00:00+01:00'),\n", - " (2030, 'TF', '02-04 09:00:00+01:00'),\n", - " (2030, 'TF', '02-04 10:00:00+01:00'),\n", - " (2030, 'TF', '02-04 11:00:00+01:00'),\n", - " (2030, 'TF', '02-04 12:00:00+01:00'),\n", - " (2030, 'TF', '02-04 13:00:00+01:00'),\n", - " (2030, 'TF', '02-04 14:00:00+01:00'),\n", - " (2030, 'TF', '02-04 15:00:00+01:00'),\n", - " (2030, 'TF', '02-04 16:00:00+01:00'),\n", - " (2030, 'TF', '02-04 17:00:00+01:00'),\n", - " (2030, 'TF', '02-04 18:00:00+01:00'),\n", - " (2030, 'TF', '02-04 19:00:00+01:00'),\n", - " (2030, 'TF', '02-04 20:00:00+01:00'),\n", - " (2030, 'TF', '02-04 21:00:00+01:00'),\n", - " (2030, 'TF', '02-04 22:00:00+01:00'),\n", - " (2030, 'TF', '02-04 23:00:00+01:00'),\n", - " (2030, 'TF', '02-05 00:00:00+01:00'),\n", - " (2030, 'TF', '02-05 01:00:00+01:00'),\n", - " (2030, 'TF', '02-05 02:00:00+01:00'),\n", - " (2030, 'TF', '02-05 03:00:00+01:00'),\n", - " (2030, 'TF', '02-05 04:00:00+01:00'),\n", - " (2030, 'TF', '02-05 05:00:00+01:00'),\n", - " (2030, 'TF', '02-05 06:00:00+01:00'),\n", - " (2030, 'TF', '02-05 07:00:00+01:00'),\n", - " (2030, 'TF', '02-05 08:00:00+01:00'),\n", - " (2030, 'TF', '02-05 09:00:00+01:00'),\n", - " (2030, 'TF', '02-05 10:00:00+01:00'),\n", - " (2030, 'TF', '02-05 11:00:00+01:00'),\n", - " (2030, 'TF', '02-05 12:00:00+01:00'),\n", - " (2030, 'TF', '02-05 13:00:00+01:00'),\n", - " (2030, 'TF', '02-05 14:00:00+01:00'),\n", - " (2030, 'TF', '02-05 15:00:00+01:00'),\n", - " (2030, 'TF', '02-05 16:00:00+01:00'),\n", - " (2030, 'TF', '02-05 17:00:00+01:00'),\n", - " (2030, 'TF', '02-05 18:00:00+01:00'),\n", - " (2030, 'TF', '02-05 19:00:00+01:00'),\n", - " (2030, 'TF', '02-05 20:00:00+01:00'),\n", - " (2030, 'TF', '02-05 21:00:00+01:00'),\n", - " (2030, 'TF', '02-05 22:00:00+01:00'),\n", - " (2030, 'TF', '02-05 23:00:00+01:00'),\n", - " (2030, 'TF', '02-06 00:00:00+01:00'),\n", - " (2030, 'TF', '02-06 01:00:00+01:00'),\n", - " (2030, 'TF', '02-06 02:00:00+01:00'),\n", - " (2030, 'TF', '02-06 03:00:00+01:00'),\n", - " (2030, 'TF', '02-06 04:00:00+01:00'),\n", - " (2030, 'TF', '02-06 05:00:00+01:00'),\n", - " (2030, 'TF', '02-06 06:00:00+01:00'),\n", - " (2030, 'TF', '02-06 07:00:00+01:00'),\n", - " (2030, 'TF', '02-06 08:00:00+01:00'),\n", - " (2030, 'TF', '02-06 09:00:00+01:00'),\n", - " (2030, 'TF', '02-06 10:00:00+01:00'),\n", - " (2030, 'TF', '02-06 11:00:00+01:00'),\n", - " (2030, 'TF', '02-06 12:00:00+01:00'),\n", - " (2030, 'TF', '02-06 13:00:00+01:00'),\n", - " (2030, 'TF', '02-06 14:00:00+01:00'),\n", - " (2030, 'TF', '02-06 15:00:00+01:00'),\n", - " (2030, 'TF', '02-06 16:00:00+01:00'),\n", - " (2030, 'TF', '02-06 17:00:00+01:00'),\n", - " (2030, 'TF', '02-06 18:00:00+01:00'),\n", - " (2030, 'TF', '02-06 19:00:00+01:00'),\n", - " (2030, 'TF', '02-06 20:00:00+01:00'),\n", - " (2030, 'TF', '02-06 21:00:00+01:00'),\n", - " (2030, 'TF', '02-06 22:00:00+01:00'),\n", - " (2030, 'TF', '02-06 23:00:00+01:00'),\n", - " (2030, 'TF', '02-07 00:00:00+01:00'),\n", - " (2030, 'TF', '02-07 01:00:00+01:00'),\n", - " (2030, 'TF', '02-07 02:00:00+01:00'),\n", - " (2030, 'TF', '02-07 03:00:00+01:00'),\n", - " (2030, 'TF', '02-07 04:00:00+01:00'),\n", - " (2030, 'TF', '02-07 05:00:00+01:00'),\n", - " (2030, 'TF', '02-07 06:00:00+01:00'),\n", - " (2030, 'TF', '02-07 07:00:00+01:00'),\n", - " (2030, 'TF', '02-07 08:00:00+01:00'),\n", - " (2030, 'TF', '02-07 09:00:00+01:00'),\n", - " (2030, 'TF', '02-07 10:00:00+01:00'),\n", - " (2030, 'TF', '02-07 11:00:00+01:00'),\n", - " (2030, 'TF', '02-07 12:00:00+01:00'),\n", - " (2030, 'TF', '02-07 13:00:00+01:00'),\n", - " (2030, 'TF', '02-07 14:00:00+01:00'),\n", - " (2030, 'TF', '02-07 15:00:00+01:00'),\n", - " (2030, 'TF', '02-07 16:00:00+01:00'),\n", - " (2030, 'TF', '02-07 17:00:00+01:00'),\n", - " (2030, 'TF', '02-07 18:00:00+01:00'),\n", - " (2030, 'TF', '02-07 19:00:00+01:00'),\n", - " (2030, 'TF', '02-07 20:00:00+01:00'),\n", - " (2030, 'TF', '02-07 21:00:00+01:00'),\n", - " (2030, 'TF', '02-07 22:00:00+01:00'),\n", - " (2030, 'TF', '02-07 23:00:00+01:00'),\n", - " (2030, 'TF', '02-08 00:00:00+01:00'),\n", - " (2030, 'TF', '02-08 01:00:00+01:00'),\n", - " (2030, 'TF', '02-08 02:00:00+01:00'),\n", - " (2030, 'TF', '02-08 03:00:00+01:00'),\n", - " (2030, 'TF', '02-08 04:00:00+01:00'),\n", - " (2030, 'TF', '02-08 05:00:00+01:00'),\n", - " (2030, 'TF', '02-08 06:00:00+01:00'),\n", - " (2030, 'TF', '02-08 07:00:00+01:00'),\n", - " (2030, 'TF', '02-08 08:00:00+01:00'),\n", - " (2030, 'TF', '02-08 09:00:00+01:00'),\n", - " (2030, 'TF', '02-08 10:00:00+01:00'),\n", - " (2030, 'TF', '02-08 11:00:00+01:00'),\n", - " (2030, 'TF', '02-08 12:00:00+01:00'),\n", - " (2030, 'TF', '02-08 13:00:00+01:00'),\n", - " (2030, 'TF', '02-08 14:00:00+01:00'),\n", - " (2030, 'TF', '02-08 15:00:00+01:00'),\n", - " (2030, 'TF', '02-08 16:00:00+01:00'),\n", - " (2030, 'TF', '02-08 17:00:00+01:00'),\n", - " (2030, 'TF', '02-08 18:00:00+01:00'),\n", - " (2030, 'TF', '02-08 19:00:00+01:00'),\n", - " (2030, 'TF', '02-08 20:00:00+01:00'),\n", - " (2030, 'TF', '02-08 21:00:00+01:00'),\n", - " (2030, 'TF', '02-08 22:00:00+01:00'),\n", - " (2030, 'TF', '02-08 23:00:00+01:00'),\n", - " (2030, 'TF', '02-09 00:00:00+01:00'),\n", - " (2030, 'TF', '02-09 01:00:00+01:00'),\n", - " (2030, 'TF', '02-09 02:00:00+01:00'),\n", - " (2030, 'TF', '02-09 03:00:00+01:00'),\n", - " (2030, 'TF', '02-09 04:00:00+01:00'),\n", - " (2030, 'TF', '02-09 05:00:00+01:00'),\n", - " (2030, 'TF', '02-09 06:00:00+01:00'),\n", - " (2030, 'TF', '02-09 07:00:00+01:00'),\n", - " (2030, 'TF', '02-09 08:00:00+01:00'),\n", - " (2030, 'TF', '02-09 09:00:00+01:00'),\n", - " (2030, 'TF', '02-09 10:00:00+01:00'),\n", - " (2030, 'TF', '02-09 11:00:00+01:00'),\n", - " (2030, 'TF', '02-09 12:00:00+01:00'),\n", - " (2030, 'TF', '02-09 13:00:00+01:00'),\n", - " (2030, 'TF', '02-09 14:00:00+01:00'),\n", - " (2030, 'TF', '02-09 15:00:00+01:00'),\n", - " (2030, 'TF', '02-09 16:00:00+01:00'),\n", - " (2030, 'TF', '02-09 17:00:00+01:00'),\n", - " (2030, 'TF', '02-09 18:00:00+01:00'),\n", - " (2030, 'TF', '02-09 19:00:00+01:00'),\n", - " (2030, 'TF', '02-09 20:00:00+01:00'),\n", - " (2030, 'TF', '02-09 21:00:00+01:00'),\n", - " (2030, 'TF', '02-09 22:00:00+01:00'),\n", - " (2030, 'TF', '02-09 23:00:00+01:00'),\n", - " (2030, 'TF', '02-10 00:00:00+01:00'),\n", - " (2030, 'TF', '02-10 01:00:00+01:00'),\n", - " (2030, 'TF', '02-10 02:00:00+01:00'),\n", - " (2030, 'TF', '02-10 03:00:00+01:00'),\n", - " (2030, 'TF', '02-10 04:00:00+01:00'),\n", - " (2030, 'TF', '02-10 05:00:00+01:00'),\n", - " (2030, 'TF', '02-10 06:00:00+01:00'),\n", - " (2030, 'TF', '02-10 07:00:00+01:00'),\n", - " (2030, 'TF', '02-10 08:00:00+01:00'),\n", - " (2030, 'TF', '02-10 09:00:00+01:00'),\n", - " (2030, 'TF', '02-10 10:00:00+01:00'),\n", - " (2030, 'TF', '02-10 11:00:00+01:00'),\n", - " (2030, 'TF', '02-10 12:00:00+01:00'),\n", - " (2030, 'TF', '02-10 13:00:00+01:00'),\n", - " (2030, 'TF', '02-10 14:00:00+01:00'),\n", - " (2030, 'TF', '02-10 15:00:00+01:00'),\n", - " (2030, 'TF', '02-10 16:00:00+01:00'),\n", - " (2030, 'TF', '02-10 17:00:00+01:00'),\n", - " (2030, 'TF', '02-10 18:00:00+01:00'),\n", - " (2030, 'TF', '02-10 19:00:00+01:00'),\n", - " (2030, 'TF', '02-10 20:00:00+01:00'),\n", - " (2030, 'TF', '02-10 21:00:00+01:00'),\n", - " (2030, 'TF', '02-10 22:00:00+01:00'),\n", - " (2030, 'TF', '02-10 23:00:00+01:00'),\n", - " (2030, 'TF', '02-11 00:00:00+01:00'),\n", - " (2030, 'TF', '02-11 01:00:00+01:00'),\n", - " (2030, 'TF', '02-11 02:00:00+01:00'),\n", - " (2030, 'TF', '02-11 03:00:00+01:00'),\n", - " (2030, 'TF', '02-11 04:00:00+01:00'),\n", - " (2030, 'TF', '02-11 05:00:00+01:00'),\n", - " (2030, 'TF', '02-11 06:00:00+01:00'),\n", - " (2030, 'TF', '02-11 07:00:00+01:00'),\n", - " (2030, 'TF', '02-11 08:00:00+01:00'),\n", - " (2030, 'TF', '02-11 09:00:00+01:00'),\n", - " (2030, 'TF', '02-11 10:00:00+01:00'),\n", - " (2030, 'TF', '02-11 11:00:00+01:00'),\n", - " (2030, 'TF', '02-11 12:00:00+01:00'),\n", - " (2030, 'TF', '02-11 13:00:00+01:00'),\n", - " (2030, 'TF', '02-11 14:00:00+01:00'),\n", - " (2030, 'TF', '02-11 15:00:00+01:00'),\n", - " ...]" - ] - }, - "execution_count": 463, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "list_idx" - ] - }, - { - "cell_type": "code", - "execution_count": 464, - "id": "26716de2", - "metadata": {}, - "outputs": [], - "source": [ - "# list.index((2030, 'TF', '01-01 00:00:00+01:00'))" - ] - }, - { - "cell_type": "code", - "execution_count": 465, - "id": "e3bcb24b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
DurationStage
2030TF01-01 00:00:00+01:001st1
01-01 01:00:00+01:001st1
01-01 02:00:00+01:001st1
01-01 03:00:00+01:001st1
01-01 04:00:00+01:001st1
.........
12-30 19:00:00+01:001st1
12-30 20:00:00+01:001st1
12-30 21:00:00+01:001st1
12-30 22:00:00+01:001st1
12-30 23:00:00+01:001st1
\n", - "

8736 rows × 2 columns

\n", - "
" - ], - "text/plain": [ - " Duration Stage\n", - "2030 TF 01-01 00:00:00+01:00 1 st1\n", - " 01-01 01:00:00+01:00 1 st1\n", - " 01-01 02:00:00+01:00 1 st1\n", - " 01-01 03:00:00+01:00 1 st1\n", - " 01-01 04:00:00+01:00 1 st1\n", - "... ... ...\n", - " 12-30 19:00:00+01:00 1 st1\n", - " 12-30 20:00:00+01:00 1 st1\n", - " 12-30 21:00:00+01:00 1 st1\n", - " 12-30 22:00:00+01:00 1 st1\n", - " 12-30 23:00:00+01:00 1 st1\n", - "\n", - "[8736 rows x 2 columns]" - ] - }, - "execution_count": 465, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dfDuration" - ] - }, - { - "cell_type": "code", - "execution_count": 466, - "id": "20dd8cb8", - "metadata": {}, - "outputs": [], - "source": [ - "# list.index((2030, 'TF', '01-01 00:00:00+01:00')) % 168 == 0" - ] - }, - { - "cell_type": "code", - "execution_count": 467, - "id": "32c6c332", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'01-01 00:00:00+01:00'" - ] - }, - "execution_count": 467, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "list_idx[0][2]" - ] - }, - { - "cell_type": "code", - "execution_count": 468, - "id": "f80f7092", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'01-01 00:00:00'" - ] - }, - "execution_count": 468, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "list_idx[0][2][:14]" - ] - }, - { - "cell_type": "code", - "execution_count": 469, - "id": "3a1bbacd", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[2030]" - ] - }, - "execution_count": 469, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# get the unique values of the first element of the tuples\n", - "unique_values = [item[0] for item in list_idx]\n", - "unique_values = set(unique_values)\n", - "unique_values = sorted([item for item in unique_values])\n", - "# unique_values = unique_values.sort()\n", - "unique_values" - ] - }, - { - "cell_type": "code", - "execution_count": 470, - "id": "e04ba00a", - "metadata": {}, - "outputs": [], - "source": [ - "b = pd.to_datetime(str(list_idx[0][0])+'-'+list_idx[0][2][:14], format='%Y-%m-%d %H:%M:%S', errors='coerce')" - ] - }, - { - "cell_type": "code", - "execution_count": 471, - "id": "23b26345", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Timestamp('2030-01-01 00:00:00')" - ] - }, - "execution_count": 471, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "b" - ] - }, - { - "cell_type": "code", - "execution_count": 472, - "id": "b6eee91f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "date: 2030-01-01 00:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 00:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 01:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 01:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 02:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 02:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 03:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 03:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 04:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 04:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 05:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 05:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 06:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 06:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 07:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 07:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 08:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 08:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 09:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 09:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 10:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 10:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 11:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 11:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 12:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 12:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 13:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 13:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 14:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 14:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 15:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 15:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 16:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 16:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 17:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 17:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 18:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 18:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 19:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 19:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 20:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 20:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 21:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 21:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 22:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 22:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-01 23:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-01 23:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 00:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 00:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 01:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 01:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 02:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 02:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 03:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 03:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 04:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 04:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 05:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 05:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 06:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 06:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 07:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 07:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 08:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 08:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 09:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 09:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 10:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 10:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 11:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 11:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 12:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 12:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 13:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 13:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 14:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 14:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 15:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 15:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 16:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 16:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 17:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 17:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 18:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 18:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 19:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 19:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 20:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 20:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 21:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 21:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 22:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 22:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-02 23:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-02 23:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 00:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 00:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 01:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 01:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 02:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 02:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 03:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 03:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 04:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 04:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 05:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 05:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 06:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 06:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 07:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 07:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 08:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 08:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 09:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 09:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 10:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 10:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 11:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 11:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 12:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 12:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 13:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 13:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 14:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 14:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 15:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 15:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 16:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 16:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 17:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 17:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 18:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 18:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 19:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 19:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 20:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 20:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 21:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 21:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 22:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 22:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-03 23:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-03 23:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 00:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 00:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 01:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 01:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 02:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 02:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 03:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 03:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 04:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 04:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 05:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 05:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 06:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 06:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 07:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 07:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 08:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 08:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 09:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 09:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 10:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 10:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 11:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 11:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 12:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 12:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 13:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 13:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 14:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 14:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 15:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 15:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 16:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 16:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 17:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 17:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 18:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 18:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 19:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 19:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 20:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 20:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 21:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 21:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 22:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 22:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-04 23:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-04 23:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 00:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 00:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 01:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 01:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 02:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 02:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 03:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 03:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 04:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 04:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 05:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 05:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 06:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 06:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 07:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 07:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 08:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 08:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 09:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 09:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 10:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 10:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 11:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 11:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 12:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 12:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 13:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 13:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 14:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 14:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 15:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 15:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 16:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 16:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 17:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 17:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 18:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 18:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 19:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 19:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 20:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 20:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 21:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 21:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 22:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 22:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-05 23:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-05 23:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 00:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 00:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 01:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 01:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 02:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 02:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 03:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 03:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 04:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 04:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 05:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 05:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 06:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 06:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 07:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 07:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 08:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 08:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 09:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 09:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 10:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 10:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 11:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 11:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 12:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 12:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 13:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 13:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 14:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 14:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 15:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 15:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 16:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 16:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 17:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 17:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 18:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 18:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 19:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 19:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 20:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 20:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 21:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 21:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 22:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 22:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-06 23:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-06 23:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-01-07 00:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 00:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 01:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 01:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 02:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 02:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 03:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 03:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 04:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 04:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 05:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 05:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 06:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 06:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 07:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 07:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 08:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 08:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 09:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 09:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 10:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 10:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 11:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 11:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 12:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 12:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 13:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 13:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 14:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 14:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 15:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 15:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 16:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 16:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 17:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 17:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 18:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 18:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 19:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 19:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 20:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 20:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 21:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 21:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 22:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 22:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-07 23:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-07 23:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 00:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 00:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 01:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 01:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 02:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 02:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 03:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 03:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 04:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 04:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 05:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 05:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 06:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 06:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 07:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 07:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 08:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 08:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 09:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 09:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 10:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 10:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 11:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 11:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 12:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 12:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 13:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 13:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 14:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 14:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 15:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 15:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 16:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 16:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 17:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 17:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 18:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 18:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 19:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 19:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 20:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 20:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 21:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 21:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 22:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 22:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-08 23:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-08 23:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 00:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 00:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 01:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 01:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 02:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 02:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 03:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 03:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 04:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 04:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 05:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 05:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 06:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 06:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 07:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 07:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 08:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 08:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 09:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 09:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 10:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 10:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 11:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 11:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 12:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 12:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 13:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 13:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 14:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 14:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 15:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 15:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 16:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 16:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 17:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 17:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 18:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 18:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 19:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 19:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 20:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 20:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 21:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 21:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 22:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 22:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-09 23:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-09 23:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 00:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 00:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 01:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 01:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 02:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 02:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 03:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 03:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 04:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 04:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 05:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 05:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 06:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 06:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 07:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 07:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 08:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 08:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 09:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 09:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 10:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 10:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 11:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 11:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 12:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 12:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 13:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 13:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 14:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 14:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 15:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 15:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 16:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 16:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 17:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 17:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 18:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 18:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 19:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 19:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 20:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 20:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 21:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 21:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 22:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 22:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-10 23:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-10 23:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 00:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 00:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 01:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 01:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 02:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 02:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 03:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 03:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 04:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 04:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 05:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 05:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 06:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 06:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 07:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 07:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 08:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 08:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 09:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 09:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 10:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 10:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 11:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 11:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 12:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 12:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 13:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 13:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 14:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 14:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 15:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 15:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 16:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 16:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 17:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 17:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 18:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 18:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 19:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 19:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 20:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 20:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 21:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 21:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 22:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 22:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-11 23:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-11 23:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 00:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 00:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 01:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 01:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 02:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 02:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 03:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 03:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 04:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 04:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 05:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 05:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 06:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 06:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 07:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 07:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 08:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 08:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 09:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 09:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 10:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 10:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 11:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 11:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 12:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 12:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 13:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 13:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 14:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 14:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 15:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 15:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 16:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 16:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 17:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 17:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 18:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 18:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 19:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 19:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 20:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 20:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 21:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 21:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 22:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 22:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-12 23:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-12 23:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 00:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 00:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 01:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 01:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 02:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 02:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 03:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 03:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 04:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 04:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 05:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 05:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 06:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 06:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 07:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 07:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 08:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 08:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 09:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 09:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 10:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 10:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 11:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 11:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 12:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 12:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 13:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 13:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 14:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 14:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 15:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 15:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 16:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 16:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 17:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 17:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 18:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 18:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 19:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 19:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 20:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 20:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 21:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 21:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 22:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 22:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-13 23:00:00\n", - "week: 1\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-13 23:00:00+01:00') week: 1 stage: st0 duration: 0\n", - "date: 2030-01-14 00:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 00:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 01:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 01:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 02:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 02:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 03:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 03:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 04:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 04:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 05:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 05:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 06:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 06:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 07:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 07:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 08:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 08:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 09:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 09:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 10:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 10:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 11:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 11:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 12:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 12:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 13:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 13:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 14:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 14:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 15:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 15:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 16:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 16:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 17:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 17:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 18:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 18:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 19:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 19:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 20:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 20:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 21:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 21:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 22:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 22:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-14 23:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-14 23:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 00:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 00:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 01:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 01:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 02:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 02:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 03:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 03:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 04:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 04:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 05:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 05:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 06:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 06:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 07:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 07:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 08:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 08:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 09:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 09:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 10:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 10:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 11:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 11:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 12:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 12:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 13:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 13:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 14:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 14:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 15:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 15:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 16:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 16:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 17:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 17:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 18:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 18:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 19:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 19:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 20:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 20:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 21:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 21:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 22:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 22:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-15 23:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-15 23:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 00:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 00:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 01:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 01:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 02:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 02:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 03:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 03:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 04:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 04:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 05:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 05:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 06:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 06:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 07:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 07:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 08:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 08:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 09:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 09:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 10:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 10:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 11:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 11:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 12:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 12:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 13:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 13:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 14:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 14:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 15:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 15:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 16:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 16:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 17:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 17:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 18:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 18:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 19:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 19:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 20:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 20:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 21:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 21:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 22:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 22:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-16 23:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-16 23:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 00:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 00:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 01:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 01:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 02:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 02:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 03:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 03:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 04:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 04:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 05:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 05:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 06:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 06:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 07:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 07:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 08:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 08:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 09:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 09:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 10:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 10:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 11:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 11:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 12:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 12:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 13:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 13:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 14:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 14:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 15:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 15:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 16:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 16:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 17:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 17:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 18:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 18:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 19:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 19:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 20:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 20:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 21:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 21:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 22:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 22:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-17 23:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-17 23:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 00:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 00:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 01:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 01:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 02:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 02:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 03:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 03:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 04:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 04:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 05:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 05:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 06:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 06:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 07:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 07:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 08:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 08:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 09:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 09:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 10:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 10:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 11:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 11:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 12:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 12:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 13:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 13:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 14:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 14:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 15:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 15:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 16:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 16:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 17:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 17:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 18:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 18:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 19:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 19:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 20:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 20:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 21:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 21:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 22:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 22:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-18 23:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-18 23:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 00:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 00:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 01:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 01:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 02:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 02:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 03:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 03:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 04:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 04:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 05:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 05:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 06:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 06:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 07:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 07:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 08:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 08:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 09:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 09:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 10:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 10:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 11:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 11:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 12:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 12:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 13:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 13:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 14:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 14:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 15:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 15:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 16:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 16:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 17:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 17:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 18:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 18:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 19:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 19:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 20:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 20:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 21:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 21:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 22:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 22:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-19 23:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-19 23:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 00:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 00:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 01:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 01:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 02:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 02:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 03:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 03:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 04:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 04:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 05:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 05:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 06:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 06:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 07:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 07:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 08:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 08:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 09:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 09:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 10:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 10:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 11:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 11:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 12:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 12:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 13:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 13:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 14:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 14:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 15:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 15:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 16:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 16:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 17:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 17:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 18:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 18:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 19:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 19:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 20:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 20:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 21:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 21:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 22:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 22:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-20 23:00:00\n", - "week: 2\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-20 23:00:00+01:00') week: 2 stage: st0 duration: 0\n", - "date: 2030-01-21 00:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 00:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 01:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 01:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 02:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 02:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 03:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 03:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 04:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 04:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 05:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 05:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 06:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 06:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 07:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 07:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 08:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 08:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 09:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 09:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 10:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 10:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 11:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 11:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 12:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 12:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 13:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 13:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 14:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 14:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 15:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 15:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 16:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 16:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 17:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 17:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 18:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 18:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 19:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 19:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 20:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 20:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 21:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 21:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 22:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 22:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-21 23:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-21 23:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 00:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 00:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 01:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 01:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 02:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 02:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 03:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 03:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 04:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 04:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 05:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 05:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 06:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 06:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 07:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 07:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 08:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 08:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 09:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 09:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 10:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 10:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 11:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 11:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 12:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 12:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 13:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 13:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 14:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 14:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 15:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 15:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 16:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 16:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 17:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 17:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 18:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 18:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 19:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 19:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 20:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 20:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 21:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 21:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 22:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 22:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-22 23:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-22 23:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 00:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 00:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 01:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 01:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 02:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 02:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 03:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 03:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 04:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 04:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 05:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 05:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 06:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 06:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 07:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 07:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 08:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 08:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 09:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 09:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 10:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 10:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 11:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 11:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 12:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 12:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 13:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 13:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 14:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 14:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 15:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 15:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 16:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 16:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 17:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 17:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 18:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 18:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 19:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 19:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 20:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 20:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 21:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 21:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 22:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 22:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-23 23:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-23 23:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 00:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 00:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 01:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 01:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 02:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 02:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 03:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 03:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 04:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 04:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 05:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 05:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 06:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 06:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 07:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 07:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 08:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 08:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 09:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 09:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 10:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 10:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 11:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 11:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 12:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 12:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 13:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 13:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 14:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 14:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 15:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 15:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 16:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 16:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 17:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 17:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 18:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 18:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 19:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 19:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 20:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 20:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 21:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 21:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 22:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 22:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-24 23:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-24 23:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 00:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 00:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 01:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 01:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 02:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 02:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 03:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 03:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 04:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 04:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 05:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 05:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 06:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 06:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 07:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 07:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 08:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 08:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 09:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 09:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 10:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 10:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 11:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 11:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 12:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 12:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 13:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 13:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 14:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 14:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 15:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 15:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 16:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 16:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 17:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 17:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 18:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 18:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 19:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 19:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 20:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 20:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 21:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 21:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 22:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 22:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-25 23:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-25 23:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 00:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 00:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 01:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 01:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 02:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 02:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 03:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 03:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 04:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 04:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 05:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 05:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 06:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 06:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 07:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 07:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 08:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 08:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 09:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 09:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 10:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 10:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 11:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 11:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 12:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 12:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 13:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 13:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 14:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 14:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 15:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 15:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 16:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 16:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 17:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 17:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 18:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 18:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 19:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 19:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 20:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 20:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 21:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 21:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 22:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 22:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-26 23:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-26 23:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 00:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 00:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 01:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 01:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 02:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 02:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 03:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 03:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 04:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 04:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 05:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 05:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 06:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 06:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 07:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 07:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 08:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 08:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 09:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 09:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 10:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 10:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 11:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 11:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 12:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 12:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 13:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 13:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 14:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 14:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 15:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 15:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 16:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 16:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 17:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 17:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 18:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 18:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 19:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 19:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 20:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 20:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 21:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 21:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 22:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 22:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-27 23:00:00\n", - "week: 3\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-27 23:00:00+01:00') week: 3 stage: st0 duration: 0\n", - "date: 2030-01-28 00:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 00:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 01:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 01:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 02:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 02:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 03:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 03:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 04:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 04:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 05:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 05:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 06:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 06:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 07:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 07:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 08:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 08:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 09:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 09:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 10:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 10:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 11:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 11:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 12:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 12:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 13:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 13:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 14:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 14:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 15:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 15:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 16:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 16:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 17:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 17:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 18:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 18:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 19:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 19:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 20:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 20:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 21:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 21:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 22:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 22:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-28 23:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-28 23:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 00:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 00:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 01:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 01:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 02:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 02:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 03:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 03:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 04:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 04:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 05:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 05:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 06:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 06:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 07:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 07:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 08:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 08:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 09:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 09:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 10:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 10:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 11:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 11:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 12:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 12:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 13:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 13:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 14:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 14:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 15:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 15:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 16:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 16:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 17:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 17:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 18:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 18:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 19:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 19:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 20:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 20:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 21:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 21:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 22:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 22:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-29 23:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-29 23:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 00:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 00:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 01:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 01:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 02:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 02:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 03:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 03:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 04:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 04:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 05:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 05:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 06:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 06:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 07:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 07:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 08:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 08:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 09:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 09:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 10:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 10:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 11:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 11:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 12:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 12:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 13:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 13:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 14:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 14:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 15:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 15:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 16:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 16:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 17:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 17:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 18:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 18:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 19:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 19:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 20:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 20:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 21:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 21:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 22:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 22:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-30 23:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-30 23:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 00:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 00:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 01:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 01:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 02:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 02:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 03:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 03:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 04:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 04:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 05:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 05:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 06:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 06:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 07:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 07:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 08:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 08:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 09:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 09:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 10:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 10:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 11:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 11:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 12:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 12:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 13:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 13:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 14:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 14:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 15:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 15:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 16:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 16:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 17:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 17:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 18:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 18:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 19:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 19:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 20:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 20:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 21:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 21:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 22:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 22:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-01-31 23:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '01-31 23:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 00:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 00:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 01:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 01:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 02:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 02:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 03:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 03:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 04:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 04:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 05:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 05:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 06:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 06:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 07:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 07:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 08:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 08:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 09:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 09:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 10:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 10:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 11:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 11:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 12:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 12:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 13:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 13:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 14:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 14:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 15:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 15:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 16:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 16:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 17:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 17:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 18:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 18:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 19:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 19:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 20:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 20:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 21:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 21:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 22:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 22:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-01 23:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-01 23:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 00:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 00:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 01:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 01:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 02:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 02:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 03:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 03:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 04:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 04:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 05:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 05:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 06:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 06:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 07:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 07:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 08:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 08:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 09:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 09:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 10:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 10:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 11:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 11:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 12:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 12:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 13:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 13:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 14:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 14:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 15:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 15:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 16:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 16:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 17:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 17:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 18:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 18:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 19:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 19:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 20:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 20:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 21:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 21:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 22:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 22:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-02 23:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-02 23:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 00:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 00:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 01:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 01:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 02:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 02:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 03:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 03:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 04:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 04:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 05:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 05:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 06:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 06:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 07:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 07:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 08:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 08:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 09:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 09:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 10:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 10:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 11:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 11:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 12:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 12:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 13:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 13:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 14:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 14:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 15:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 15:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 16:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 16:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 17:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 17:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 18:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 18:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 19:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 19:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 20:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 20:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 21:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 21:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 22:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 22:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-03 23:00:00\n", - "week: 4\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-03 23:00:00+01:00') week: 4 stage: st0 duration: 0\n", - "date: 2030-02-04 00:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 00:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 01:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 01:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 02:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 02:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 03:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 03:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 04:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 04:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 05:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 05:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 06:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 06:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 07:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 07:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 08:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 08:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 09:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 09:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 10:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 10:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 11:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 11:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 12:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 12:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 13:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 13:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 14:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 14:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 15:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 15:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 16:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 16:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 17:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 17:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 18:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 18:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 19:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 19:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 20:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 20:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 21:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 21:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 22:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 22:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-04 23:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-04 23:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 00:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 00:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 01:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 01:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 02:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 02:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 03:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 03:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 04:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 04:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 05:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 05:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 06:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 06:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 07:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 07:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 08:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 08:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 09:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 09:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 10:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 10:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 11:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 11:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 12:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 12:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 13:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 13:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 14:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 14:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 15:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 15:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 16:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 16:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 17:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 17:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 18:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 18:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 19:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 19:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 20:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 20:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 21:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 21:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 22:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 22:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-05 23:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-05 23:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 00:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 00:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 01:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 01:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 02:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 02:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 03:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 03:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 04:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 04:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 05:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 05:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 06:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 06:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 07:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 07:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 08:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 08:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 09:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 09:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 10:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 10:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 11:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 11:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 12:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 12:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 13:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 13:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 14:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 14:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 15:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 15:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 16:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 16:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 17:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 17:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 18:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 18:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 19:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 19:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 20:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 20:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 21:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 21:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 22:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 22:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-06 23:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-06 23:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 00:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 00:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 01:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 01:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 02:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 02:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 03:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 03:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 04:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 04:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 05:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 05:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 06:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 06:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 07:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 07:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 08:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 08:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 09:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 09:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 10:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 10:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 11:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 11:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 12:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 12:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 13:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 13:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 14:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 14:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 15:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 15:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 16:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 16:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 17:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 17:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 18:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 18:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 19:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 19:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 20:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 20:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 21:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 21:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 22:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 22:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-07 23:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-07 23:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 00:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 00:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 01:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 01:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 02:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 02:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 03:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 03:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 04:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 04:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 05:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 05:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 06:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 06:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 07:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 07:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 08:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 08:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 09:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 09:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 10:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 10:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 11:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 11:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 12:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 12:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 13:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 13:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 14:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 14:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 15:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 15:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 16:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 16:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 17:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 17:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 18:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 18:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 19:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 19:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 20:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 20:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 21:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 21:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 22:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 22:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-08 23:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-08 23:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 00:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 00:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 01:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 01:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 02:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 02:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 03:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 03:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 04:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 04:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 05:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 05:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 06:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 06:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 07:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 07:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 08:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 08:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 09:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 09:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 10:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 10:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 11:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 11:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 12:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 12:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 13:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 13:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 14:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 14:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 15:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 15:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 16:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 16:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 17:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 17:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 18:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 18:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 19:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 19:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 20:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 20:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 21:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 21:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 22:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 22:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-09 23:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-09 23:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 00:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 00:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 01:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 01:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 02:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 02:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 03:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 03:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 04:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 04:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 05:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 05:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 06:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 06:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 07:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 07:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 08:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 08:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 09:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 09:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 10:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 10:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 11:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 11:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 12:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 12:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 13:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 13:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 14:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 14:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 15:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 15:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 16:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 16:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 17:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 17:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 18:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 18:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 19:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 19:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 20:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 20:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 21:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 21:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 22:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 22:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-10 23:00:00\n", - "week: 5\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-10 23:00:00+01:00') week: 5 stage: st0 duration: 0\n", - "date: 2030-02-11 00:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 00:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 01:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 01:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 02:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 02:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 03:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 03:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 04:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 04:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 05:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 05:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 06:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 06:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 07:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 07:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 08:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 08:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 09:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 09:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 10:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 10:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 11:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 11:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 12:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 12:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 13:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 13:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 14:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 14:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 15:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 15:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 16:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 16:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 17:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 17:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 18:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 18:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 19:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 19:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 20:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 20:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 21:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 21:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 22:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 22:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-11 23:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-11 23:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 00:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 00:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 01:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 01:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 02:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 02:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 03:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 03:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 04:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 04:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 05:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 05:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 06:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 06:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 07:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 07:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 08:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 08:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 09:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 09:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 10:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 10:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 11:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 11:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 12:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 12:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 13:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 13:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 14:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 14:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 15:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 15:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 16:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 16:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 17:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 17:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 18:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 18:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 19:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 19:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 20:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 20:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 21:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 21:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 22:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 22:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-12 23:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-12 23:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 00:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 00:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 01:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 01:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 02:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 02:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 03:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 03:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 04:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 04:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 05:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 05:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 06:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 06:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 07:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 07:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 08:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 08:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 09:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 09:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 10:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 10:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 11:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 11:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 12:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 12:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 13:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 13:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 14:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 14:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 15:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 15:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 16:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 16:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 17:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 17:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 18:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 18:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 19:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 19:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 20:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 20:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 21:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 21:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 22:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 22:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-13 23:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-13 23:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 00:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 00:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 01:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 01:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 02:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 02:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 03:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 03:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 04:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 04:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 05:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 05:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 06:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 06:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 07:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 07:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 08:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 08:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 09:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 09:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 10:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 10:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 11:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 11:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 12:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 12:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 13:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 13:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 14:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 14:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 15:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 15:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 16:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 16:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 17:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 17:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 18:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 18:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 19:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 19:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 20:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 20:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 21:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 21:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 22:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 22:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-14 23:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-14 23:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 00:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 00:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 01:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 01:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 02:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 02:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 03:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 03:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 04:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 04:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 05:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 05:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 06:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 06:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 07:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 07:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 08:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 08:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 09:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 09:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 10:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 10:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 11:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 11:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 12:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 12:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 13:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 13:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 14:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 14:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 15:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 15:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 16:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 16:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 17:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 17:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 18:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 18:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 19:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 19:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 20:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 20:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 21:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 21:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 22:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 22:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-15 23:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-15 23:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 00:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 00:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 01:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 01:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 02:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 02:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 03:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 03:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 04:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 04:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 05:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 05:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 06:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 06:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 07:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 07:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 08:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 08:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 09:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 09:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 10:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 10:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 11:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 11:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 12:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 12:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 13:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 13:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 14:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 14:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 15:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 15:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 16:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 16:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 17:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 17:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 18:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 18:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 19:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 19:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 20:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 20:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 21:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 21:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 22:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 22:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-16 23:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-16 23:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 00:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 00:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 01:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 01:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 02:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 02:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 03:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 03:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 04:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 04:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 05:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 05:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 06:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 06:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 07:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 07:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 08:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 08:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 09:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 09:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 10:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 10:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 11:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 11:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 12:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 12:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 13:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 13:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 14:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 14:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 15:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 15:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 16:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 16:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 17:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 17:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 18:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 18:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 19:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 19:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 20:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 20:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 21:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 21:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 22:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 22:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-17 23:00:00\n", - "week: 6\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-17 23:00:00+01:00') week: 6 stage: st0 duration: 0\n", - "date: 2030-02-18 00:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 00:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 01:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 01:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 02:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 02:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 03:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 03:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 04:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 04:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 05:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 05:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 06:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 06:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 07:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 07:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 08:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 08:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 09:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 09:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 10:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 10:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 11:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 11:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 12:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 12:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 13:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 13:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 14:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 14:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 15:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 15:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 16:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 16:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 17:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 17:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 18:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 18:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 19:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 19:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 20:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 20:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 21:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 21:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 22:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 22:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-18 23:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-18 23:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 00:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 00:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 01:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 01:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 02:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 02:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 03:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 03:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 04:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 04:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 05:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 05:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 06:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 06:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 07:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 07:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 08:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 08:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 09:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 09:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 10:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 10:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 11:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 11:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 12:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 12:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 13:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 13:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 14:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 14:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 15:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 15:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 16:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 16:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 17:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 17:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 18:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 18:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 19:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 19:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 20:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 20:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 21:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 21:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 22:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 22:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-19 23:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-19 23:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 00:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 00:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 01:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 01:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 02:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 02:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 03:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 03:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 04:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 04:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 05:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 05:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 06:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 06:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 07:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 07:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 08:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 08:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 09:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 09:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 10:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 10:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 11:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 11:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 12:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 12:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 13:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 13:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 14:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 14:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 15:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 15:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 16:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 16:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 17:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 17:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 18:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 18:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 19:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 19:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 20:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 20:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 21:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 21:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 22:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 22:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-20 23:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-20 23:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 00:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 00:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 01:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 01:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 02:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 02:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 03:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 03:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 04:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 04:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 05:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 05:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 06:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 06:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 07:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 07:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 08:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 08:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 09:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 09:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 10:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 10:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 11:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 11:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 12:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 12:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 13:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 13:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 14:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 14:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 15:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 15:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 16:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 16:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 17:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 17:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 18:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 18:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 19:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 19:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 20:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 20:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 21:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 21:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 22:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 22:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-21 23:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-21 23:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 00:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 00:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 01:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 01:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 02:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 02:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 03:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 03:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 04:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 04:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 05:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 05:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 06:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 06:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 07:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 07:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 08:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 08:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 09:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 09:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 10:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 10:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 11:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 11:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 12:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 12:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 13:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 13:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 14:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 14:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 15:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 15:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 16:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 16:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 17:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 17:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 18:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 18:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 19:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 19:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 20:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 20:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 21:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 21:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 22:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 22:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-22 23:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-22 23:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 00:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 00:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 01:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 01:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 02:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 02:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 03:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 03:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 04:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 04:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 05:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 05:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 06:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 06:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 07:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 07:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 08:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 08:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 09:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 09:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 10:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 10:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 11:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 11:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 12:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 12:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 13:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 13:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 14:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 14:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 15:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 15:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 16:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 16:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 17:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 17:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 18:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 18:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 19:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 19:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 20:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 20:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 21:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 21:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 22:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 22:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-23 23:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-23 23:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 00:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 00:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 01:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 01:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 02:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 02:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 03:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 03:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 04:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 04:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 05:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 05:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 06:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 06:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 07:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 07:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 08:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 08:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 09:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 09:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 10:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 10:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 11:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 11:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 12:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 12:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 13:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 13:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 14:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 14:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 15:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 15:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 16:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 16:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 17:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 17:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 18:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 18:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 19:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 19:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 20:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 20:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 21:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 21:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 22:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 22:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-24 23:00:00\n", - "week: 7\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-24 23:00:00+01:00') week: 7 stage: st0 duration: 0\n", - "date: 2030-02-25 00:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 00:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 01:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 01:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 02:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 02:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 03:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 03:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 04:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 04:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 05:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 05:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 06:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 06:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 07:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 07:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 08:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 08:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 09:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 09:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 10:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 10:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 11:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 11:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 12:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 12:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 13:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 13:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 14:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 14:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 15:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 15:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 16:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 16:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 17:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 17:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 18:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 18:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 19:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 19:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 20:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 20:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 21:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 21:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 22:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 22:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-25 23:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-25 23:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 00:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 00:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 01:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 01:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 02:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 02:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 03:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 03:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 04:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 04:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 05:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 05:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 06:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 06:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 07:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 07:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 08:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 08:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 09:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 09:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 10:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 10:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 11:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 11:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 12:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 12:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 13:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 13:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 14:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 14:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 15:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 15:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 16:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 16:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 17:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 17:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 18:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 18:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 19:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 19:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 20:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 20:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 21:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 21:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 22:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 22:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-26 23:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-26 23:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 00:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 00:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 01:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 01:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 02:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 02:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 03:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 03:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 04:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 04:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 05:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 05:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 06:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 06:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 07:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 07:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 08:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 08:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 09:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 09:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 10:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 10:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 11:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 11:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 12:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 12:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 13:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 13:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 14:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 14:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 15:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 15:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 16:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 16:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 17:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 17:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 18:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 18:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 19:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 19:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 20:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 20:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 21:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 21:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 22:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 22:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-27 23:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-27 23:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 00:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 00:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 01:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 01:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 02:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 02:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 03:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 03:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 04:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 04:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 05:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 05:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 06:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 06:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 07:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 07:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 08:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 08:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 09:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 09:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 10:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 10:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 11:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 11:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 12:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 12:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 13:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 13:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 14:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 14:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 15:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 15:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 16:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 16:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 17:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 17:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 18:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 18:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 19:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 19:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 20:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 20:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 21:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 21:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 22:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 22:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-02-28 23:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '02-28 23:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 00:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 00:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 01:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 01:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 02:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 02:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 03:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 03:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 04:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 04:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 05:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 05:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 06:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 06:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 07:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 07:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 08:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 08:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 09:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 09:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 10:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 10:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 11:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 11:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 12:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 12:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 13:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 13:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 14:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 14:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 15:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 15:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 16:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 16:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 17:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 17:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 18:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 18:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 19:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 19:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 20:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 20:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 21:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 21:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 22:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 22:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-01 23:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-01 23:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 00:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 00:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 01:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 01:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 02:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 02:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 03:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 03:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 04:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 04:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 05:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 05:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 06:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 06:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 07:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 07:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 08:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 08:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 09:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 09:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 10:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 10:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 11:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 11:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 12:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 12:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 13:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 13:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 14:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 14:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 15:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 15:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 16:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 16:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 17:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 17:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 18:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 18:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 19:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 19:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 20:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 20:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 21:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 21:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 22:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 22:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-02 23:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-02 23:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 00:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 00:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 01:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 01:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 02:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 02:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 03:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 03:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 04:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 04:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 05:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 05:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 06:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 06:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 07:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 07:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 08:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 08:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 09:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 09:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 10:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 10:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 11:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 11:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 12:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 12:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 13:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 13:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 14:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 14:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 15:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 15:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 16:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 16:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 17:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 17:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 18:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 18:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 19:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 19:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 20:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 20:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 21:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 21:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 22:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 22:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-03 23:00:00\n", - "week: 8\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-03 23:00:00+01:00') week: 8 stage: st0 duration: 0\n", - "date: 2030-03-04 00:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 00:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 01:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 01:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 02:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 02:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 03:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 03:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 04:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 04:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 05:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 05:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 06:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 06:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 07:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 07:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 08:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 08:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 09:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 09:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 10:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 10:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 11:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 11:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 12:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 12:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 13:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 13:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 14:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 14:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 15:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 15:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 16:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 16:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 17:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 17:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 18:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 18:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 19:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 19:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 20:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 20:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 21:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 21:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 22:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 22:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-04 23:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-04 23:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 00:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 00:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 01:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 01:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 02:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 02:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 03:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 03:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 04:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 04:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 05:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 05:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 06:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 06:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 07:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 07:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 08:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 08:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 09:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 09:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 10:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 10:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 11:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 11:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 12:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 12:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 13:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 13:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 14:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 14:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 15:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 15:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 16:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 16:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 17:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 17:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 18:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 18:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 19:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 19:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 20:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 20:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 21:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 21:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 22:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 22:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-05 23:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-05 23:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 00:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 00:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 01:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 01:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 02:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 02:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 03:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 03:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 04:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 04:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 05:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 05:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 06:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 06:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 07:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 07:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 08:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 08:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 09:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 09:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 10:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 10:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 11:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 11:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 12:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 12:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 13:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 13:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 14:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 14:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 15:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 15:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 16:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 16:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 17:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 17:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 18:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 18:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 19:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 19:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 20:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 20:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 21:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 21:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 22:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 22:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-06 23:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-06 23:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 00:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 00:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 01:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 01:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 02:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 02:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 03:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 03:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 04:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 04:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 05:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 05:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 06:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 06:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 07:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 07:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 08:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 08:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 09:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 09:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 10:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 10:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 11:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 11:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 12:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 12:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 13:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 13:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 14:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 14:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 15:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 15:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 16:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 16:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 17:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 17:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 18:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 18:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 19:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 19:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 20:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 20:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 21:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 21:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 22:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 22:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-07 23:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-07 23:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 00:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 00:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 01:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 01:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 02:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 02:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 03:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 03:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 04:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 04:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 05:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 05:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 06:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 06:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 07:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 07:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 08:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 08:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 09:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 09:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 10:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 10:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 11:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 11:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 12:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 12:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 13:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 13:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 14:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 14:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 15:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 15:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 16:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 16:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 17:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 17:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 18:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 18:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 19:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 19:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 20:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 20:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 21:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 21:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 22:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 22:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-08 23:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-08 23:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 00:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 00:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 01:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 01:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 02:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 02:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 03:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 03:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 04:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 04:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 05:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 05:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 06:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 06:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 07:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 07:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 08:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 08:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 09:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 09:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 10:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 10:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 11:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 11:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 12:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 12:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 13:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 13:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 14:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 14:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 15:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 15:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 16:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 16:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 17:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 17:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 18:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 18:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 19:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 19:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 20:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 20:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 21:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 21:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 22:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 22:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-09 23:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-09 23:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 00:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 00:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 01:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 01:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 02:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 02:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 03:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 03:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 04:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 04:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 05:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 05:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 06:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 06:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 07:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 07:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 08:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 08:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 09:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 09:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 10:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 10:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 11:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 11:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 12:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 12:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 13:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 13:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 14:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 14:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 15:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 15:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 16:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 16:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 17:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 17:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 18:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 18:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 19:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 19:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 20:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 20:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 21:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 21:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 22:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 22:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-10 23:00:00\n", - "week: 9\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-10 23:00:00+01:00') week: 9 stage: st0 duration: 1\n", - "date: 2030-03-11 00:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 00:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 01:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 01:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 02:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 02:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 03:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 03:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 04:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 04:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 05:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 05:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 06:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 06:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 07:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 07:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 08:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 08:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 09:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 09:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 10:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 10:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 11:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 11:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 12:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 12:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 13:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 13:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 14:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 14:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 15:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 15:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 16:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 16:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 17:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 17:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 18:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 18:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 19:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 19:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 20:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 20:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 21:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 21:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 22:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 22:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-11 23:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-11 23:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 00:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 00:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 01:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 01:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 02:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 02:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 03:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 03:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 04:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 04:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 05:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 05:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 06:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 06:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 07:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 07:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 08:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 08:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 09:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 09:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 10:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 10:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 11:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 11:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 12:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 12:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 13:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 13:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 14:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 14:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 15:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 15:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 16:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 16:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 17:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 17:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 18:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 18:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 19:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 19:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 20:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 20:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 21:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 21:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 22:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 22:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-12 23:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-12 23:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 00:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 00:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 01:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 01:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 02:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 02:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 03:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 03:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 04:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 04:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 05:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 05:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 06:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 06:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 07:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 07:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 08:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 08:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 09:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 09:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 10:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 10:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 11:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 11:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 12:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 12:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 13:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 13:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 14:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 14:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 15:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 15:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 16:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 16:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 17:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 17:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 18:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 18:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 19:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 19:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 20:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 20:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 21:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 21:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 22:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 22:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-13 23:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-13 23:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 00:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 00:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 01:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 01:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 02:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 02:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 03:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 03:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 04:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 04:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 05:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 05:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 06:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 06:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 07:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 07:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 08:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 08:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 09:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 09:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 10:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 10:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 11:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 11:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 12:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 12:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 13:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 13:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 14:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 14:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 15:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 15:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 16:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 16:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 17:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 17:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 18:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 18:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 19:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 19:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 20:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 20:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 21:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 21:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 22:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 22:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-14 23:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-14 23:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 00:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 00:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 01:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 01:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 02:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 02:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 03:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 03:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 04:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 04:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 05:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 05:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 06:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 06:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 07:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 07:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 08:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 08:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 09:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 09:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 10:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 10:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 11:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 11:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 12:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 12:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 13:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 13:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 14:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 14:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 15:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 15:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 16:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 16:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 17:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 17:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 18:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 18:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 19:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 19:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 20:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 20:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 21:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 21:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 22:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 22:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-15 23:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-15 23:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 00:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 00:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 01:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 01:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 02:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 02:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 03:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 03:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 04:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 04:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 05:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 05:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 06:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 06:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 07:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 07:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 08:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 08:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 09:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 09:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 10:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 10:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 11:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 11:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 12:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 12:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 13:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 13:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 14:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 14:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 15:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 15:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 16:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 16:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 17:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 17:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 18:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 18:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 19:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 19:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 20:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 20:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 21:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 21:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 22:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 22:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-16 23:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-16 23:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 00:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 00:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 01:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 01:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 02:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 02:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 03:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 03:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 04:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 04:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 05:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 05:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 06:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 06:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 07:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 07:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 08:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 08:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 09:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 09:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 10:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 10:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 11:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 11:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 12:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 12:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 13:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 13:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 14:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 14:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 15:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 15:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 16:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 16:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 17:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 17:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 18:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 18:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 19:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 19:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 20:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 20:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 21:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 21:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 22:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 22:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-17 23:00:00\n", - "week: 10\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-17 23:00:00+01:00') week: 10 stage: st0 duration: 0\n", - "date: 2030-03-18 00:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 00:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 01:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 01:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 02:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 02:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 03:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 03:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 04:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 04:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 05:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 05:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 06:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 06:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 07:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 07:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 08:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 08:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 09:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 09:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 10:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 10:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 11:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 11:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 12:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 12:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 13:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 13:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 14:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 14:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 15:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 15:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 16:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 16:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 17:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 17:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 18:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 18:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 19:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 19:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 20:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 20:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 21:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 21:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 22:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 22:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-18 23:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-18 23:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 00:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 00:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 01:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 01:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 02:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 02:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 03:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 03:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 04:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 04:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 05:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 05:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 06:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 06:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 07:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 07:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 08:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 08:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 09:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 09:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 10:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 10:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 11:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 11:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 12:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 12:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 13:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 13:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 14:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 14:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 15:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 15:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 16:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 16:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 17:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 17:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 18:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 18:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 19:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 19:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 20:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 20:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 21:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 21:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 22:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 22:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-19 23:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-19 23:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 00:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 00:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 01:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 01:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 02:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 02:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 03:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 03:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 04:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 04:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 05:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 05:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 06:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 06:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 07:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 07:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 08:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 08:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 09:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 09:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 10:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 10:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 11:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 11:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 12:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 12:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 13:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 13:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 14:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 14:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 15:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 15:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 16:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 16:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 17:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 17:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 18:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 18:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 19:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 19:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 20:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 20:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 21:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 21:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 22:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 22:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-20 23:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-20 23:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 00:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 00:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 01:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 01:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 02:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 02:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 03:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 03:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 04:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 04:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 05:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 05:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 06:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 06:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 07:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 07:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 08:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 08:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 09:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 09:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 10:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 10:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 11:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 11:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 12:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 12:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 13:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 13:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 14:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 14:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 15:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 15:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 16:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 16:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 17:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 17:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 18:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 18:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 19:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 19:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 20:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 20:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 21:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 21:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 22:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 22:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-21 23:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-21 23:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 00:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 00:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 01:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 01:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 02:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 02:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 03:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 03:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 04:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 04:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 05:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 05:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 06:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 06:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 07:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 07:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 08:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 08:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 09:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 09:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 10:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 10:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 11:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 11:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 12:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 12:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 13:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 13:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 14:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 14:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 15:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 15:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 16:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 16:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 17:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 17:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 18:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 18:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 19:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 19:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 20:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 20:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 21:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 21:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 22:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 22:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-22 23:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-22 23:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 00:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 00:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 01:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 01:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 02:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 02:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 03:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 03:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 04:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 04:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 05:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 05:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 06:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 06:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 07:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 07:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 08:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 08:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 09:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 09:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 10:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 10:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 11:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 11:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 12:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 12:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 13:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 13:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 14:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 14:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 15:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 15:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 16:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 16:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 17:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 17:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 18:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 18:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 19:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 19:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 20:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 20:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 21:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 21:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 22:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 22:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-23 23:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-23 23:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 00:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 00:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 01:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 01:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 02:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 02:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 03:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 03:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 04:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 04:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 05:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 05:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 06:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 06:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 07:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 07:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 08:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 08:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 09:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 09:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 10:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 10:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 11:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 11:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 12:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 12:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 13:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 13:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 14:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 14:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 15:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 15:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 16:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 16:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 17:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 17:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 18:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 18:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 19:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 19:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 20:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 20:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 21:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 21:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 22:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 22:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-24 23:00:00\n", - "week: 11\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-24 23:00:00+01:00') week: 11 stage: st0 duration: 0\n", - "date: 2030-03-25 00:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 00:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 01:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 01:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 02:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 02:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 03:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 03:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 04:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 04:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 05:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 05:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 06:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 06:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 07:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 07:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 08:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 08:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 09:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 09:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 10:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 10:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 11:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 11:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 12:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 12:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 13:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 13:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 14:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 14:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 15:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 15:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 16:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 16:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 17:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 17:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 18:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 18:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 19:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 19:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 20:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 20:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 21:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 21:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 22:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 22:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-25 23:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-25 23:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 00:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 00:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 01:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 01:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 02:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 02:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 03:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 03:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 04:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 04:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 05:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 05:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 06:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 06:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 07:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 07:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 08:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 08:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 09:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 09:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 10:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 10:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 11:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 11:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 12:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 12:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 13:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 13:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 14:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 14:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 15:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 15:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 16:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 16:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 17:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 17:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 18:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 18:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 19:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 19:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 20:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 20:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 21:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 21:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 22:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 22:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-26 23:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-26 23:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 00:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 00:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 01:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 01:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 02:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 02:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 03:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 03:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 04:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 04:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 05:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 05:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 06:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 06:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 07:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 07:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 08:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 08:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 09:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 09:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 10:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 10:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 11:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 11:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 12:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 12:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 13:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 13:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 14:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 14:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 15:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 15:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 16:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 16:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 17:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 17:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 18:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 18:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 19:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 19:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 20:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 20:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 21:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 21:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 22:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 22:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-27 23:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-27 23:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 00:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 00:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 01:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 01:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 02:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 02:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 03:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 03:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 04:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 04:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 05:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 05:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 06:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 06:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 07:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 07:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 08:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 08:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 09:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 09:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 10:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 10:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 11:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 11:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 12:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 12:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 13:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 13:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 14:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 14:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 15:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 15:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 16:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 16:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 17:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 17:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 18:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 18:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 19:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 19:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 20:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 20:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 21:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 21:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 22:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 22:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-28 23:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-28 23:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 00:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 00:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 01:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 01:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 02:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 02:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 03:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 03:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 04:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 04:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 05:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 05:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 06:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 06:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 07:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 07:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 08:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 08:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 09:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 09:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 10:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 10:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 11:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 11:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 12:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 12:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 13:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 13:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 14:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 14:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 15:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 15:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 16:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 16:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 17:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 17:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 18:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 18:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 19:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 19:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 20:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 20:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 21:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 21:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 22:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 22:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-29 23:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-29 23:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 00:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 00:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 01:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 01:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 02:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 02:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 03:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 03:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 04:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 04:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 05:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 05:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 06:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 06:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 07:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 07:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 08:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 08:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 09:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 09:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 10:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 10:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 11:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 11:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 12:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 12:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 13:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 13:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 14:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 14:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 15:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 15:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 16:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 16:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 17:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 17:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 18:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 18:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 19:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 19:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 20:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 20:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 21:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 21:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 22:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 22:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-30 23:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-30 23:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 00:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 00:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 01:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 01:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 02:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 02:00:00+01:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 03:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 03:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 04:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 04:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 05:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 05:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 06:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 06:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 07:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 07:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 08:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 08:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 09:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 09:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 10:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 10:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 11:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 11:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 12:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 12:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 13:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 13:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 14:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 14:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 15:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 15:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 16:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 16:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 17:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 17:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 18:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 18:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 19:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 19:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 20:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 20:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 21:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 21:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 22:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 22:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-03-31 23:00:00\n", - "week: 12\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '03-31 23:00:00+02:00') week: 12 stage: st0 duration: 0\n", - "date: 2030-04-01 00:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 00:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 01:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 01:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 02:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 02:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 03:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 03:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 04:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 04:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 05:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 05:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 06:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 06:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 07:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 07:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 08:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 08:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 09:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 09:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 10:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 10:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 11:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 11:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 12:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 12:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 13:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 13:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 14:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 14:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 15:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 15:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 16:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 16:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 17:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 17:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 18:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 18:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 19:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 19:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 20:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 20:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 21:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 21:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 22:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 22:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-01 23:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-01 23:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 00:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 00:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 01:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 01:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 02:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 02:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 03:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 03:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 04:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 04:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 05:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 05:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 06:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 06:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 07:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 07:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 08:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 08:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 09:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 09:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 10:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 10:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 11:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 11:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 12:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 12:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 13:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 13:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 14:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 14:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 15:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 15:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 16:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 16:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 17:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 17:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 18:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 18:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 19:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 19:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 20:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 20:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 21:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 21:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 22:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 22:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-02 23:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-02 23:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 00:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 00:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 01:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 01:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 02:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 02:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 03:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 03:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 04:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 04:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 05:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 05:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 06:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 06:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 07:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 07:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 08:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 08:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 09:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 09:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 10:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 10:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 11:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 11:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 12:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 12:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 13:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 13:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 14:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 14:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 15:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 15:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 16:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 16:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 17:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 17:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 18:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 18:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 19:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 19:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 20:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 20:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 21:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 21:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 22:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 22:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-03 23:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-03 23:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 00:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 00:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 01:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 01:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 02:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 02:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 03:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 03:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 04:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 04:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 05:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 05:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 06:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 06:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 07:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 07:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 08:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 08:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 09:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 09:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 10:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 10:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 11:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 11:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 12:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 12:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 13:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 13:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 14:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 14:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 15:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 15:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 16:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 16:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 17:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 17:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 18:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 18:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 19:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 19:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 20:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 20:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 21:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 21:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 22:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 22:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-04 23:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-04 23:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 00:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 00:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 01:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 01:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 02:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 02:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 03:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 03:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 04:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 04:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 05:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 05:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 06:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 06:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 07:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 07:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 08:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 08:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 09:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 09:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 10:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 10:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 11:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 11:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 12:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 12:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 13:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 13:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 14:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 14:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 15:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 15:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 16:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 16:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 17:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 17:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 18:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 18:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 19:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 19:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 20:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 20:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 21:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 21:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 22:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 22:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-05 23:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-05 23:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 00:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 00:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 01:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 01:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 02:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 02:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 03:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 03:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 04:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 04:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 05:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 05:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 06:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 06:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 07:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 07:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 08:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 08:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 09:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 09:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 10:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 10:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 11:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 11:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 12:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 12:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 13:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 13:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 14:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 14:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 15:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 15:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 16:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 16:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 17:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 17:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 18:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 18:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 19:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 19:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 20:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 20:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 21:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 21:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 22:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 22:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-06 23:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-06 23:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 00:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 00:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 01:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 01:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 02:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 02:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 03:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 03:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 04:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 04:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 05:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 05:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 06:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 06:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 07:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 07:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 08:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 08:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 09:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 09:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 10:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 10:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 11:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 11:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 12:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 12:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 13:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 13:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 14:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 14:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 15:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 15:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 16:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 16:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 17:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 17:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 18:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 18:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 19:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 19:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 20:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 20:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 21:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 21:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 22:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 22:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-07 23:00:00\n", - "week: 13\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-07 23:00:00+02:00') week: 13 stage: st0 duration: 0\n", - "date: 2030-04-08 00:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 00:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 01:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 01:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 02:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 02:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 03:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 03:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 04:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 04:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 05:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 05:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 06:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 06:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 07:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 07:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 08:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 08:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 09:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 09:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 10:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 10:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 11:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 11:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 12:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 12:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 13:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 13:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 14:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 14:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 15:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 15:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 16:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 16:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 17:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 17:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 18:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 18:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 19:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 19:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 20:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 20:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 21:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 21:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 22:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 22:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-08 23:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-08 23:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 00:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 00:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 01:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 01:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 02:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 02:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 03:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 03:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 04:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 04:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 05:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 05:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 06:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 06:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 07:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 07:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 08:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 08:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 09:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 09:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 10:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 10:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 11:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 11:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 12:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 12:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 13:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 13:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 14:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 14:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 15:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 15:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 16:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 16:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 17:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 17:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 18:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 18:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 19:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 19:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 20:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 20:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 21:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 21:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 22:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 22:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-09 23:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-09 23:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 00:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 00:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 01:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 01:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 02:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 02:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 03:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 03:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 04:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 04:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 05:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 05:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 06:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 06:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 07:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 07:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 08:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 08:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 09:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 09:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 10:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 10:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 11:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 11:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 12:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 12:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 13:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 13:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 14:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 14:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 15:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 15:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 16:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 16:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 17:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 17:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 18:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 18:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 19:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 19:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 20:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 20:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 21:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 21:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 22:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 22:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-10 23:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-10 23:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 00:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 00:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 01:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 01:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 02:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 02:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 03:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 03:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 04:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 04:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 05:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 05:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 06:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 06:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 07:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 07:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 08:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 08:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 09:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 09:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 10:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 10:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 11:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 11:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 12:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 12:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 13:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 13:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 14:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 14:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 15:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 15:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 16:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 16:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 17:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 17:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 18:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 18:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 19:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 19:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 20:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 20:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 21:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 21:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 22:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 22:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-11 23:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-11 23:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 00:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 00:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 01:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 01:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 02:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 02:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 03:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 03:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 04:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 04:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 05:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 05:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 06:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 06:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 07:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 07:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 08:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 08:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 09:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 09:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 10:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 10:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 11:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 11:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 12:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 12:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 13:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 13:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 14:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 14:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 15:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 15:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 16:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 16:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 17:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 17:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 18:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 18:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 19:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 19:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 20:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 20:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 21:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 21:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 22:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 22:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-12 23:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-12 23:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 00:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 00:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 01:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 01:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 02:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 02:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 03:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 03:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 04:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 04:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 05:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 05:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 06:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 06:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 07:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 07:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 08:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 08:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 09:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 09:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 10:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 10:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 11:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 11:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 12:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 12:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 13:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 13:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 14:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 14:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 15:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 15:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 16:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 16:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 17:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 17:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 18:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 18:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 19:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 19:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 20:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 20:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 21:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 21:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 22:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 22:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-13 23:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-13 23:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 00:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 00:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 01:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 01:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 02:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 02:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 03:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 03:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 04:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 04:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 05:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 05:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 06:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 06:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 07:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 07:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 08:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 08:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 09:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 09:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 10:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 10:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 11:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 11:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 12:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 12:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 13:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 13:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 14:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 14:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 15:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 15:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 16:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 16:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 17:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 17:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 18:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 18:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 19:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 19:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 20:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 20:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 21:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 21:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 22:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 22:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-14 23:00:00\n", - "week: 14\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-14 23:00:00+02:00') week: 14 stage: st0 duration: 0\n", - "date: 2030-04-15 00:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 00:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 01:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 01:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 02:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 02:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 03:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 03:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 04:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 04:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 05:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 05:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 06:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 06:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 07:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 07:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 08:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 08:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 09:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 09:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 10:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 10:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 11:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 11:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 12:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 12:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 13:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 13:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 14:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 14:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 15:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 15:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 16:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 16:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 17:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 17:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 18:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 18:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 19:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 19:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 20:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 20:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 21:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 21:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 22:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 22:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-15 23:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-15 23:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 00:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 00:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 01:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 01:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 02:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 02:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 03:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 03:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 04:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 04:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 05:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 05:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 06:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 06:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 07:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 07:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 08:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 08:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 09:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 09:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 10:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 10:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 11:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 11:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 12:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 12:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 13:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 13:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 14:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 14:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 15:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 15:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 16:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 16:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 17:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 17:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 18:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 18:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 19:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 19:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 20:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 20:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 21:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 21:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 22:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 22:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-16 23:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-16 23:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 00:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 00:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 01:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 01:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 02:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 02:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 03:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 03:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 04:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 04:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 05:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 05:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 06:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 06:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 07:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 07:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 08:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 08:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 09:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 09:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 10:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 10:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 11:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 11:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 12:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 12:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 13:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 13:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 14:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 14:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 15:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 15:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 16:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 16:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 17:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 17:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 18:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 18:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 19:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 19:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 20:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 20:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 21:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 21:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 22:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 22:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-17 23:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-17 23:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 00:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 00:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 01:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 01:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 02:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 02:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 03:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 03:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 04:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 04:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 05:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 05:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 06:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 06:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 07:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 07:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 08:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 08:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 09:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 09:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 10:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 10:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 11:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 11:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 12:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 12:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 13:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 13:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 14:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 14:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 15:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 15:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 16:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 16:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 17:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 17:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 18:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 18:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 19:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 19:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 20:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 20:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 21:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 21:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 22:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 22:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-18 23:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-18 23:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 00:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 00:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 01:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 01:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 02:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 02:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 03:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 03:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 04:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 04:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 05:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 05:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 06:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 06:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 07:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 07:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 08:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 08:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 09:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 09:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 10:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 10:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 11:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 11:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 12:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 12:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 13:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 13:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 14:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 14:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 15:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 15:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 16:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 16:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 17:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 17:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 18:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 18:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 19:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 19:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 20:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 20:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 21:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 21:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 22:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 22:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-19 23:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-19 23:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 00:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 00:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 01:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 01:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 02:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 02:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 03:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 03:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 04:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 04:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 05:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 05:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 06:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 06:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 07:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 07:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 08:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 08:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 09:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 09:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 10:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 10:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 11:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 11:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 12:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 12:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 13:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 13:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 14:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 14:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 15:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 15:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 16:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 16:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 17:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 17:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 18:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 18:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 19:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 19:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 20:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 20:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 21:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 21:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 22:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 22:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-20 23:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-20 23:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 00:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 00:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 01:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 01:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 02:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 02:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 03:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 03:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 04:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 04:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 05:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 05:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 06:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 06:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 07:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 07:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 08:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 08:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 09:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 09:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 10:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 10:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 11:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 11:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 12:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 12:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 13:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 13:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 14:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 14:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 15:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 15:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 16:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 16:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 17:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 17:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 18:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 18:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 19:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 19:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 20:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 20:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 21:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 21:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 22:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 22:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-21 23:00:00\n", - "week: 15\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-21 23:00:00+02:00') week: 15 stage: st0 duration: 0\n", - "date: 2030-04-22 00:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 00:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 01:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 01:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 02:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 02:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 03:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 03:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 04:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 04:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 05:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 05:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 06:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 06:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 07:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 07:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 08:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 08:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 09:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 09:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 10:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 10:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 11:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 11:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 12:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 12:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 13:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 13:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 14:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 14:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 15:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 15:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 16:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 16:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 17:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 17:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 18:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 18:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 19:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 19:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 20:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 20:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 21:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 21:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 22:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 22:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-22 23:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-22 23:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 00:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 00:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 01:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 01:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 02:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 02:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 03:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 03:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 04:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 04:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 05:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 05:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 06:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 06:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 07:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 07:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 08:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 08:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 09:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 09:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 10:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 10:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 11:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 11:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 12:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 12:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 13:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 13:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 14:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 14:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 15:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 15:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 16:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 16:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 17:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 17:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 18:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 18:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 19:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 19:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 20:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 20:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 21:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 21:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 22:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 22:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-23 23:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-23 23:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 00:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 00:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 01:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 01:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 02:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 02:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 03:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 03:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 04:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 04:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 05:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 05:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 06:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 06:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 07:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 07:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 08:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 08:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 09:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 09:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 10:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 10:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 11:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 11:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 12:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 12:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 13:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 13:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 14:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 14:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 15:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 15:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 16:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 16:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 17:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 17:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 18:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 18:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 19:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 19:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 20:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 20:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 21:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 21:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 22:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 22:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-24 23:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-24 23:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 00:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 00:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 01:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 01:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 02:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 02:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 03:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 03:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 04:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 04:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 05:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 05:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 06:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 06:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 07:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 07:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 08:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 08:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 09:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 09:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 10:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 10:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 11:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 11:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 12:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 12:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 13:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 13:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 14:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 14:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 15:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 15:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 16:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 16:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 17:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 17:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 18:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 18:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 19:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 19:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 20:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 20:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 21:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 21:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 22:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 22:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-25 23:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-25 23:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 00:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 00:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 01:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 01:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 02:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 02:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 03:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 03:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 04:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 04:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 05:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 05:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 06:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 06:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 07:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 07:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 08:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 08:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 09:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 09:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 10:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 10:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 11:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 11:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 12:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 12:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 13:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 13:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 14:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 14:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 15:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 15:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 16:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 16:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 17:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 17:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 18:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 18:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 19:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 19:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 20:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 20:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 21:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 21:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 22:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 22:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-26 23:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-26 23:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 00:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 00:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 01:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 01:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 02:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 02:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 03:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 03:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 04:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 04:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 05:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 05:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 06:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 06:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 07:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 07:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 08:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 08:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 09:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 09:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 10:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 10:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 11:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 11:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 12:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 12:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 13:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 13:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 14:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 14:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 15:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 15:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 16:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 16:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 17:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 17:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 18:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 18:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 19:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 19:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 20:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 20:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 21:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 21:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 22:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 22:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-27 23:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-27 23:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 00:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 00:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 01:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 01:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 02:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 02:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 03:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 03:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 04:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 04:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 05:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 05:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 06:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 06:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 07:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 07:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 08:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 08:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 09:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 09:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 10:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 10:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 11:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 11:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 12:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 12:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 13:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 13:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 14:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 14:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 15:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 15:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 16:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 16:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 17:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 17:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 18:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 18:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 19:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 19:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 20:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 20:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 21:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 21:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 22:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 22:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-28 23:00:00\n", - "week: 16\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-28 23:00:00+02:00') week: 16 stage: st0 duration: 0\n", - "date: 2030-04-29 00:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 00:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 01:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 01:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 02:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 02:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 03:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 03:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 04:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 04:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 05:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 05:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 06:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 06:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 07:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 07:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 08:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 08:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 09:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 09:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 10:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 10:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 11:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 11:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 12:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 12:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 13:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 13:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 14:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 14:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 15:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 15:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 16:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 16:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 17:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 17:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 18:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 18:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 19:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 19:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 20:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 20:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 21:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 21:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 22:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 22:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-29 23:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-29 23:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 00:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 00:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 01:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 01:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 02:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 02:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 03:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 03:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 04:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 04:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 05:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 05:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 06:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 06:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 07:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 07:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 08:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 08:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 09:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 09:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 10:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 10:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 11:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 11:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 12:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 12:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 13:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 13:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 14:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 14:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 15:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 15:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 16:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 16:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 17:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 17:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 18:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 18:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 19:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 19:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 20:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 20:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 21:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 21:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 22:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 22:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-04-30 23:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '04-30 23:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 00:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 00:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 01:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 01:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 02:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 02:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 03:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 03:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 04:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 04:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 05:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 05:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 06:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 06:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 07:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 07:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 08:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 08:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 09:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 09:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 10:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 10:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 11:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 11:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 12:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 12:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 13:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 13:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 14:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 14:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 15:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 15:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 16:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 16:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 17:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 17:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 18:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 18:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 19:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 19:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 20:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 20:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 21:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 21:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 22:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 22:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-01 23:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-01 23:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 00:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 00:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 01:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 01:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 02:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 02:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 03:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 03:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 04:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 04:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 05:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 05:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 06:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 06:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 07:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 07:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 08:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 08:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 09:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 09:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 10:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 10:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 11:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 11:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 12:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 12:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 13:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 13:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 14:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 14:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 15:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 15:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 16:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 16:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 17:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 17:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 18:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 18:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 19:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 19:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 20:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 20:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 21:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 21:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 22:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 22:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-02 23:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-02 23:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 00:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 00:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 01:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 01:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 02:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 02:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 03:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 03:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 04:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 04:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 05:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 05:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 06:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 06:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 07:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 07:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 08:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 08:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 09:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 09:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 10:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 10:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 11:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 11:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 12:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 12:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 13:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 13:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 14:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 14:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 15:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 15:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 16:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 16:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 17:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 17:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 18:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 18:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 19:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 19:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 20:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 20:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 21:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 21:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 22:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 22:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-03 23:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-03 23:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 00:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 00:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 01:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 01:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 02:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 02:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 03:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 03:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 04:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 04:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 05:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 05:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 06:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 06:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 07:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 07:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 08:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 08:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 09:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 09:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 10:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 10:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 11:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 11:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 12:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 12:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 13:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 13:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 14:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 14:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 15:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 15:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 16:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 16:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 17:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 17:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 18:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 18:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 19:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 19:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 20:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 20:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 21:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 21:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 22:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 22:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-04 23:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-04 23:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 00:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 00:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 01:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 01:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 02:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 02:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 03:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 03:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 04:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 04:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 05:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 05:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 06:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 06:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 07:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 07:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 08:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 08:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 09:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 09:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 10:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 10:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 11:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 11:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 12:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 12:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 13:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 13:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 14:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 14:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 15:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 15:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 16:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 16:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 17:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 17:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 18:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 18:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 19:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 19:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 20:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 20:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 21:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 21:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 22:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 22:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-05 23:00:00\n", - "week: 17\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-05 23:00:00+02:00') week: 17 stage: st0 duration: 0\n", - "date: 2030-05-06 00:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 00:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 01:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 01:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 02:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 02:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 03:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 03:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 04:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 04:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 05:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 05:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 06:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 06:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 07:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 07:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 08:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 08:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 09:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 09:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 10:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 10:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 11:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 11:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 12:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 12:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 13:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 13:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 14:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 14:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 15:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 15:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 16:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 16:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 17:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 17:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 18:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 18:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 19:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 19:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 20:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 20:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 21:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 21:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 22:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 22:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-06 23:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-06 23:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 00:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 00:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 01:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 01:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 02:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 02:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 03:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 03:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 04:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 04:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 05:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 05:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 06:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 06:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 07:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 07:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 08:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 08:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 09:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 09:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 10:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 10:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 11:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 11:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 12:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 12:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 13:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 13:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 14:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 14:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 15:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 15:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 16:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 16:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 17:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 17:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 18:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 18:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 19:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 19:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 20:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 20:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 21:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 21:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 22:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 22:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-07 23:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-07 23:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 00:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 00:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 01:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 01:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 02:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 02:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 03:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 03:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 04:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 04:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 05:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 05:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 06:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 06:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 07:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 07:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 08:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 08:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 09:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 09:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 10:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 10:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 11:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 11:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 12:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 12:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 13:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 13:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 14:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 14:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 15:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 15:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 16:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 16:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 17:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 17:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 18:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 18:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 19:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 19:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 20:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 20:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 21:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 21:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 22:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 22:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-08 23:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-08 23:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 00:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 00:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 01:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 01:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 02:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 02:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 03:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 03:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 04:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 04:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 05:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 05:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 06:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 06:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 07:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 07:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 08:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 08:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 09:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 09:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 10:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 10:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 11:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 11:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 12:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 12:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 13:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 13:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 14:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 14:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 15:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 15:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 16:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 16:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 17:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 17:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 18:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 18:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 19:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 19:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 20:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 20:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 21:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 21:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 22:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 22:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-09 23:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-09 23:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 00:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 00:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 01:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 01:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 02:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 02:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 03:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 03:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 04:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 04:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 05:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 05:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 06:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 06:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 07:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 07:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 08:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 08:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 09:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 09:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 10:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 10:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 11:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 11:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 12:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 12:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 13:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 13:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 14:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 14:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 15:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 15:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 16:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 16:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 17:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 17:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 18:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 18:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 19:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 19:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 20:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 20:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 21:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 21:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 22:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 22:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-10 23:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-10 23:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 00:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 00:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 01:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 01:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 02:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 02:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 03:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 03:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 04:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 04:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 05:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 05:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 06:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 06:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 07:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 07:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 08:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 08:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 09:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 09:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 10:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 10:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 11:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 11:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 12:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 12:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 13:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 13:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 14:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 14:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 15:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 15:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 16:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 16:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 17:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 17:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 18:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 18:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 19:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 19:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 20:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 20:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 21:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 21:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 22:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 22:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-11 23:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-11 23:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 00:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 00:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 01:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 01:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 02:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 02:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 03:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 03:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 04:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 04:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 05:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 05:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 06:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 06:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 07:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 07:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 08:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 08:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 09:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 09:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 10:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 10:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 11:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 11:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 12:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 12:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 13:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 13:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 14:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 14:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 15:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 15:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 16:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 16:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 17:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 17:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 18:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 18:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 19:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 19:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 20:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 20:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 21:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 21:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 22:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 22:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-12 23:00:00\n", - "week: 18\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-12 23:00:00+02:00') week: 18 stage: st0 duration: 0\n", - "date: 2030-05-13 00:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 00:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 01:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 01:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 02:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 02:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 03:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 03:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 04:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 04:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 05:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 05:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 06:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 06:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 07:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 07:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 08:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 08:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 09:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 09:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 10:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 10:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 11:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 11:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 12:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 12:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 13:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 13:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 14:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 14:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 15:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 15:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 16:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 16:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 17:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 17:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 18:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 18:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 19:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 19:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 20:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 20:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 21:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 21:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 22:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 22:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-13 23:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-13 23:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 00:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 00:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 01:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 01:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 02:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 02:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 03:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 03:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 04:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 04:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 05:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 05:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 06:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 06:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 07:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 07:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 08:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 08:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 09:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 09:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 10:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 10:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 11:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 11:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 12:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 12:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 13:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 13:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 14:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 14:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 15:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 15:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 16:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 16:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 17:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 17:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 18:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 18:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 19:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 19:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 20:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 20:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 21:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 21:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 22:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 22:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-14 23:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-14 23:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 00:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 00:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 01:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 01:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 02:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 02:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 03:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 03:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 04:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 04:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 05:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 05:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 06:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 06:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 07:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 07:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 08:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 08:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 09:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 09:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 10:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 10:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 11:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 11:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 12:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 12:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 13:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 13:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 14:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 14:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 15:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 15:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 16:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 16:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 17:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 17:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 18:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 18:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 19:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 19:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 20:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 20:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 21:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 21:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 22:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 22:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-15 23:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-15 23:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 00:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 00:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 01:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 01:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 02:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 02:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 03:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 03:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 04:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 04:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 05:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 05:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 06:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 06:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 07:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 07:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 08:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 08:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 09:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 09:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 10:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 10:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 11:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 11:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 12:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 12:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 13:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 13:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 14:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 14:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 15:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 15:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 16:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 16:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 17:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 17:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 18:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 18:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 19:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 19:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 20:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 20:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 21:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 21:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 22:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 22:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-16 23:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-16 23:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 00:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 00:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 01:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 01:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 02:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 02:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 03:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 03:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 04:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 04:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 05:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 05:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 06:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 06:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 07:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 07:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 08:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 08:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 09:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 09:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 10:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 10:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 11:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 11:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 12:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 12:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 13:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 13:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 14:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 14:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 15:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 15:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 16:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 16:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 17:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 17:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 18:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 18:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 19:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 19:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 20:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 20:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 21:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 21:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 22:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 22:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-17 23:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-17 23:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 00:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 00:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 01:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 01:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 02:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 02:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 03:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 03:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 04:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 04:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 05:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 05:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 06:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 06:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 07:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 07:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 08:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 08:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 09:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 09:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 10:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 10:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 11:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 11:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 12:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 12:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 13:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 13:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 14:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 14:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 15:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 15:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 16:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 16:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 17:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 17:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 18:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 18:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 19:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 19:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 20:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 20:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 21:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 21:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 22:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 22:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-18 23:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-18 23:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 00:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 00:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 01:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 01:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 02:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 02:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 03:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 03:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 04:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 04:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 05:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 05:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 06:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 06:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 07:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 07:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 08:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 08:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 09:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 09:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 10:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 10:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 11:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 11:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 12:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 12:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 13:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 13:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 14:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 14:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 15:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 15:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 16:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 16:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 17:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 17:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 18:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 18:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 19:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 19:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 20:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 20:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 21:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 21:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 22:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 22:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-19 23:00:00\n", - "week: 19\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-19 23:00:00+02:00') week: 19 stage: st0 duration: 0\n", - "date: 2030-05-20 00:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 00:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 01:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 01:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 02:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 02:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 03:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 03:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 04:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 04:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 05:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 05:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 06:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 06:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 07:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 07:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 08:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 08:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 09:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 09:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 10:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 10:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 11:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 11:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 12:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 12:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 13:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 13:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 14:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 14:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 15:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 15:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 16:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 16:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 17:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 17:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 18:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 18:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 19:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 19:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 20:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 20:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 21:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 21:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 22:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 22:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-20 23:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-20 23:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 00:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 00:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 01:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 01:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 02:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 02:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 03:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 03:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 04:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 04:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 05:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 05:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 06:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 06:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 07:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 07:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 08:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 08:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 09:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 09:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 10:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 10:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 11:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 11:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 12:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 12:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 13:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 13:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 14:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 14:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 15:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 15:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 16:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 16:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 17:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 17:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 18:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 18:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 19:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 19:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 20:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 20:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 21:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 21:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 22:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 22:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-21 23:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-21 23:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 00:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 00:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 01:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 01:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 02:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 02:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 03:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 03:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 04:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 04:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 05:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 05:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 06:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 06:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 07:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 07:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 08:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 08:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 09:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 09:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 10:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 10:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 11:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 11:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 12:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 12:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 13:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 13:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 14:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 14:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 15:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 15:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 16:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 16:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 17:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 17:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 18:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 18:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 19:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 19:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 20:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 20:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 21:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 21:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 22:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 22:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-22 23:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-22 23:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 00:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 00:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 01:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 01:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 02:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 02:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 03:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 03:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 04:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 04:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 05:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 05:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 06:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 06:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 07:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 07:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 08:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 08:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 09:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 09:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 10:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 10:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 11:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 11:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 12:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 12:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 13:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 13:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 14:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 14:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 15:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 15:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 16:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 16:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 17:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 17:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 18:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 18:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 19:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 19:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 20:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 20:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 21:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 21:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 22:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 22:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-23 23:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-23 23:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 00:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 00:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 01:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 01:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 02:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 02:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 03:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 03:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 04:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 04:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 05:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 05:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 06:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 06:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 07:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 07:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 08:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 08:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 09:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 09:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 10:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 10:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 11:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 11:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 12:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 12:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 13:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 13:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 14:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 14:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 15:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 15:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 16:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 16:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 17:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 17:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 18:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 18:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 19:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 19:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 20:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 20:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 21:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 21:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 22:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 22:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-24 23:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-24 23:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 00:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 00:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 01:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 01:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 02:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 02:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 03:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 03:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 04:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 04:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 05:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 05:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 06:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 06:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 07:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 07:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 08:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 08:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 09:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 09:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 10:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 10:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 11:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 11:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 12:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 12:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 13:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 13:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 14:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 14:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 15:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 15:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 16:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 16:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 17:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 17:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 18:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 18:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 19:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 19:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 20:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 20:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 21:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 21:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 22:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 22:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-25 23:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-25 23:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 00:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 00:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 01:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 01:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 02:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 02:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 03:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 03:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 04:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 04:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 05:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 05:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 06:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 06:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 07:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 07:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 08:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 08:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 09:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 09:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 10:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 10:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 11:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 11:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 12:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 12:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 13:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 13:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 14:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 14:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 15:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 15:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 16:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 16:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 17:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 17:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 18:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 18:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 19:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 19:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 20:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 20:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 21:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 21:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 22:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 22:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-26 23:00:00\n", - "week: 20\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-26 23:00:00+02:00') week: 20 stage: st0 duration: 0\n", - "date: 2030-05-27 00:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 00:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 01:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 01:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 02:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 02:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 03:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 03:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 04:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 04:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 05:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 05:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 06:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 06:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 07:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 07:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 08:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 08:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 09:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 09:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 10:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 10:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 11:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 11:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 12:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 12:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 13:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 13:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 14:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 14:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 15:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 15:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 16:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 16:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 17:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 17:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 18:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 18:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 19:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 19:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 20:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 20:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 21:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 21:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 22:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 22:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-27 23:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-27 23:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 00:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 00:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 01:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 01:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 02:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 02:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 03:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 03:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 04:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 04:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 05:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 05:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 06:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 06:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 07:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 07:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 08:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 08:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 09:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 09:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 10:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 10:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 11:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 11:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 12:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 12:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 13:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 13:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 14:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 14:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 15:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 15:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 16:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 16:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 17:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 17:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 18:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 18:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 19:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 19:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 20:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 20:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 21:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 21:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 22:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 22:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-28 23:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-28 23:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 00:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 00:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 01:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 01:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 02:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 02:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 03:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 03:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 04:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 04:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 05:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 05:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 06:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 06:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 07:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 07:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 08:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 08:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 09:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 09:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 10:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 10:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 11:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 11:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 12:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 12:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 13:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 13:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 14:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 14:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 15:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 15:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 16:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 16:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 17:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 17:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 18:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 18:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 19:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 19:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 20:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 20:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 21:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 21:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 22:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 22:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-29 23:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-29 23:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 00:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 00:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 01:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 01:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 02:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 02:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 03:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 03:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 04:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 04:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 05:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 05:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 06:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 06:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 07:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 07:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 08:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 08:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 09:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 09:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 10:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 10:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 11:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 11:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 12:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 12:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 13:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 13:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 14:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 14:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 15:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 15:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 16:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 16:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 17:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 17:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 18:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 18:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 19:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 19:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 20:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 20:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 21:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 21:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 22:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 22:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-30 23:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-30 23:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 00:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 00:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 01:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 01:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 02:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 02:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 03:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 03:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 04:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 04:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 05:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 05:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 06:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 06:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 07:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 07:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 08:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 08:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 09:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 09:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 10:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 10:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 11:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 11:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 12:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 12:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 13:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 13:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 14:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 14:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 15:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 15:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 16:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 16:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 17:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 17:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 18:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 18:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 19:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 19:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 20:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 20:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 21:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 21:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 22:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 22:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-05-31 23:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '05-31 23:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 00:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 00:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 01:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 01:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 02:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 02:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 03:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 03:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 04:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 04:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 05:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 05:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 06:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 06:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 07:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 07:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 08:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 08:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 09:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 09:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 10:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 10:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 11:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 11:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 12:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 12:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 13:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 13:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 14:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 14:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 15:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 15:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 16:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 16:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 17:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 17:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 18:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 18:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 19:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 19:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 20:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 20:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 21:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 21:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 22:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 22:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-01 23:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-01 23:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 00:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 00:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 01:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 01:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 02:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 02:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 03:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 03:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 04:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 04:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 05:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 05:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 06:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 06:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 07:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 07:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 08:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 08:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 09:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 09:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 10:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 10:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 11:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 11:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 12:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 12:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 13:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 13:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 14:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 14:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 15:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 15:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 16:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 16:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 17:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 17:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 18:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 18:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 19:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 19:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 20:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 20:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 21:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 21:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 22:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 22:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-02 23:00:00\n", - "week: 21\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-02 23:00:00+02:00') week: 21 stage: st0 duration: 0\n", - "date: 2030-06-03 00:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 00:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 01:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 01:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 02:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 02:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 03:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 03:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 04:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 04:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 05:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 05:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 06:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 06:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 07:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 07:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 08:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 08:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 09:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 09:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 10:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 10:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 11:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 11:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 12:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 12:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 13:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 13:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 14:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 14:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 15:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 15:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 16:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 16:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 17:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 17:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 18:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 18:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 19:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 19:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 20:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 20:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 21:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 21:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 22:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 22:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-03 23:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-03 23:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 00:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 00:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 01:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 01:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 02:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 02:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 03:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 03:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 04:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 04:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 05:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 05:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 06:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 06:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 07:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 07:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 08:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 08:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 09:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 09:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 10:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 10:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 11:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 11:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 12:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 12:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 13:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 13:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 14:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 14:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 15:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 15:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 16:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 16:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 17:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 17:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 18:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 18:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 19:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 19:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 20:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 20:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 21:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 21:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 22:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 22:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-04 23:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-04 23:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 00:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 00:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 01:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 01:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 02:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 02:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 03:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 03:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 04:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 04:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 05:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 05:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 06:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 06:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 07:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 07:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 08:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 08:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 09:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 09:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 10:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 10:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 11:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 11:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 12:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 12:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 13:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 13:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 14:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 14:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 15:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 15:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 16:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 16:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 17:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 17:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 18:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 18:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 19:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 19:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 20:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 20:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 21:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 21:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 22:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 22:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-05 23:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-05 23:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 00:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 00:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 01:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 01:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 02:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 02:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 03:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 03:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 04:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 04:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 05:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 05:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 06:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 06:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 07:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 07:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 08:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 08:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 09:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 09:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 10:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 10:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 11:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 11:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 12:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 12:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 13:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 13:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 14:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 14:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 15:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 15:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 16:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 16:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 17:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 17:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 18:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 18:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 19:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 19:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 20:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 20:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 21:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 21:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 22:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 22:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-06 23:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-06 23:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 00:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 00:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 01:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 01:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 02:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 02:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 03:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 03:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 04:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 04:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 05:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 05:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 06:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 06:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 07:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 07:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 08:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 08:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 09:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 09:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 10:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 10:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 11:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 11:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 12:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 12:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 13:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 13:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 14:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 14:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 15:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 15:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 16:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 16:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 17:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 17:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 18:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 18:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 19:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 19:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 20:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 20:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 21:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 21:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 22:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 22:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-07 23:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-07 23:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 00:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 00:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 01:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 01:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 02:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 02:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 03:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 03:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 04:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 04:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 05:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 05:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 06:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 06:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 07:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 07:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 08:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 08:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 09:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 09:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 10:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 10:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 11:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 11:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 12:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 12:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 13:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 13:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 14:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 14:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 15:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 15:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 16:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 16:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 17:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 17:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 18:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 18:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 19:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 19:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 20:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 20:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 21:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 21:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 22:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 22:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-08 23:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-08 23:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 00:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 00:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 01:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 01:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 02:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 02:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 03:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 03:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 04:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 04:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 05:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 05:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 06:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 06:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 07:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 07:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 08:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 08:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 09:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 09:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 10:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 10:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 11:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 11:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 12:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 12:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 13:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 13:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 14:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 14:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 15:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 15:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 16:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 16:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 17:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 17:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 18:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 18:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 19:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 19:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 20:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 20:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 21:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 21:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 22:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 22:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-09 23:00:00\n", - "week: 22\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-09 23:00:00+02:00') week: 22 stage: st0 duration: 0\n", - "date: 2030-06-10 00:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 00:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 01:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 01:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 02:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 02:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 03:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 03:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 04:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 04:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 05:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 05:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 06:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 06:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 07:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 07:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 08:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 08:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 09:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 09:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 10:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 10:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 11:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 11:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 12:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 12:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 13:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 13:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 14:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 14:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 15:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 15:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 16:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 16:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 17:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 17:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 18:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 18:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 19:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 19:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 20:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 20:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 21:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 21:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 22:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 22:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-10 23:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-10 23:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 00:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 00:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 01:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 01:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 02:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 02:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 03:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 03:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 04:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 04:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 05:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 05:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 06:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 06:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 07:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 07:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 08:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 08:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 09:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 09:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 10:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 10:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 11:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 11:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 12:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 12:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 13:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 13:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 14:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 14:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 15:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 15:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 16:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 16:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 17:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 17:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 18:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 18:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 19:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 19:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 20:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 20:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 21:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 21:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 22:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 22:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-11 23:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-11 23:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 00:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 00:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 01:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 01:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 02:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 02:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 03:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 03:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 04:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 04:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 05:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 05:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 06:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 06:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 07:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 07:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 08:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 08:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 09:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 09:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 10:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 10:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 11:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 11:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 12:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 12:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 13:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 13:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 14:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 14:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 15:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 15:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 16:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 16:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 17:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 17:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 18:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 18:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 19:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 19:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 20:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 20:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 21:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 21:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 22:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 22:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-12 23:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-12 23:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 00:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 00:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 01:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 01:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 02:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 02:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 03:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 03:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 04:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 04:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 05:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 05:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 06:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 06:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 07:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 07:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 08:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 08:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 09:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 09:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 10:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 10:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 11:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 11:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 12:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 12:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 13:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 13:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 14:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 14:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 15:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 15:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 16:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 16:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 17:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 17:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 18:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 18:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 19:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 19:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 20:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 20:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 21:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 21:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 22:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 22:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-13 23:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-13 23:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 00:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 00:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 01:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 01:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 02:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 02:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 03:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 03:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 04:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 04:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 05:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 05:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 06:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 06:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 07:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 07:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 08:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 08:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 09:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 09:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 10:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 10:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 11:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 11:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 12:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 12:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 13:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 13:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 14:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 14:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 15:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 15:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 16:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 16:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 17:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 17:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 18:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 18:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 19:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 19:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 20:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 20:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 21:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 21:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 22:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 22:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-14 23:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-14 23:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 00:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 00:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 01:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 01:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 02:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 02:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 03:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 03:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 04:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 04:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 05:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 05:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 06:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 06:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 07:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 07:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 08:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 08:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 09:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 09:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 10:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 10:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 11:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 11:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 12:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 12:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 13:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 13:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 14:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 14:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 15:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 15:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 16:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 16:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 17:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 17:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 18:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 18:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 19:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 19:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 20:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 20:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 21:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 21:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 22:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 22:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-15 23:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-15 23:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 00:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 00:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 01:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 01:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 02:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 02:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 03:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 03:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 04:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 04:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 05:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 05:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 06:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 06:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 07:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 07:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 08:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 08:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 09:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 09:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 10:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 10:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 11:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 11:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 12:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 12:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 13:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 13:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 14:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 14:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 15:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 15:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 16:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 16:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 17:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 17:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 18:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 18:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 19:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 19:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 20:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 20:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 21:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 21:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 22:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 22:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-16 23:00:00\n", - "week: 23\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-16 23:00:00+02:00') week: 23 stage: st0 duration: 0\n", - "date: 2030-06-17 00:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 00:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 01:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 01:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 02:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 02:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 03:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 03:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 04:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 04:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 05:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 05:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 06:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 06:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 07:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 07:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 08:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 08:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 09:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 09:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 10:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 10:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 11:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 11:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 12:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 12:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 13:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 13:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 14:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 14:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 15:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 15:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 16:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 16:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 17:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 17:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 18:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 18:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 19:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 19:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 20:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 20:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 21:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 21:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 22:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 22:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-17 23:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-17 23:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 00:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 00:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 01:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 01:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 02:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 02:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 03:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 03:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 04:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 04:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 05:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 05:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 06:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 06:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 07:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 07:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 08:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 08:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 09:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 09:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 10:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 10:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 11:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 11:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 12:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 12:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 13:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 13:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 14:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 14:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 15:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 15:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 16:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 16:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 17:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 17:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 18:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 18:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 19:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 19:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 20:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 20:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 21:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 21:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 22:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 22:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-18 23:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-18 23:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 00:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 00:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 01:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 01:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 02:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 02:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 03:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 03:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 04:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 04:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 05:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 05:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 06:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 06:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 07:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 07:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 08:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 08:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 09:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 09:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 10:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 10:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 11:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 11:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 12:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 12:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 13:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 13:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 14:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 14:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 15:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 15:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 16:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 16:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 17:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 17:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 18:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 18:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 19:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 19:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 20:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 20:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 21:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 21:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 22:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 22:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-19 23:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-19 23:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 00:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 00:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 01:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 01:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 02:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 02:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 03:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 03:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 04:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 04:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 05:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 05:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 06:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 06:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 07:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 07:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 08:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 08:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 09:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 09:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 10:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 10:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 11:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 11:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 12:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 12:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 13:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 13:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 14:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 14:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 15:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 15:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 16:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 16:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 17:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 17:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 18:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 18:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 19:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 19:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 20:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 20:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 21:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 21:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 22:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 22:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-20 23:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-20 23:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 00:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 00:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 01:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 01:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 02:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 02:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 03:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 03:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 04:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 04:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 05:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 05:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 06:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 06:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 07:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 07:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 08:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 08:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 09:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 09:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 10:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 10:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 11:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 11:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 12:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 12:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 13:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 13:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 14:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 14:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 15:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 15:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 16:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 16:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 17:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 17:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 18:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 18:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 19:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 19:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 20:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 20:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 21:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 21:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 22:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 22:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-21 23:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-21 23:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 00:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 00:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 01:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 01:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 02:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 02:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 03:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 03:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 04:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 04:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 05:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 05:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 06:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 06:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 07:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 07:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 08:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 08:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 09:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 09:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 10:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 10:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 11:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 11:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 12:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 12:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 13:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 13:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 14:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 14:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 15:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 15:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 16:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 16:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 17:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 17:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 18:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 18:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 19:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 19:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 20:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 20:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 21:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 21:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 22:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 22:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-22 23:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-22 23:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 00:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 00:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 01:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 01:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 02:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 02:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 03:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 03:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 04:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 04:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 05:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 05:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 06:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 06:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 07:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 07:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 08:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 08:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 09:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 09:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 10:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 10:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 11:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 11:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 12:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 12:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 13:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 13:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 14:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 14:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 15:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 15:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 16:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 16:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 17:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 17:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 18:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 18:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 19:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 19:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 20:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 20:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 21:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 21:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 22:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 22:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-23 23:00:00\n", - "week: 24\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-23 23:00:00+02:00') week: 24 stage: st0 duration: 0\n", - "date: 2030-06-24 00:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 00:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 01:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 01:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 02:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 02:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 03:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 03:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 04:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 04:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 05:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 05:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 06:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 06:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 07:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 07:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 08:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 08:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 09:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 09:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 10:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 10:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 11:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 11:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 12:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 12:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 13:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 13:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 14:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 14:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 15:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 15:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 16:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 16:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 17:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 17:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 18:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 18:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 19:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 19:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 20:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 20:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 21:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 21:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 22:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 22:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-24 23:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-24 23:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 00:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 00:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 01:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 01:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 02:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 02:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 03:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 03:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 04:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 04:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 05:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 05:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 06:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 06:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 07:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 07:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 08:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 08:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 09:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 09:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 10:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 10:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 11:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 11:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 12:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 12:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 13:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 13:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 14:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 14:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 15:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 15:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 16:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 16:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 17:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 17:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 18:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 18:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 19:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 19:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 20:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 20:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 21:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 21:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 22:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 22:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-25 23:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-25 23:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 00:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 00:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 01:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 01:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 02:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 02:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 03:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 03:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 04:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 04:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 05:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 05:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 06:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 06:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 07:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 07:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 08:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 08:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 09:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 09:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 10:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 10:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 11:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 11:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 12:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 12:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 13:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 13:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 14:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 14:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 15:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 15:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 16:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 16:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 17:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 17:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 18:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 18:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 19:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 19:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 20:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 20:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 21:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 21:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 22:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 22:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-26 23:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-26 23:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 00:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 00:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 01:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 01:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 02:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 02:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 03:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 03:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 04:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 04:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 05:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 05:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 06:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 06:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 07:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 07:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 08:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 08:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 09:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 09:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 10:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 10:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 11:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 11:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 12:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 12:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 13:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 13:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 14:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 14:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 15:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 15:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 16:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 16:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 17:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 17:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 18:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 18:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 19:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 19:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 20:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 20:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 21:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 21:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 22:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 22:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-27 23:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-27 23:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 00:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 00:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 01:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 01:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 02:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 02:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 03:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 03:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 04:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 04:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 05:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 05:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 06:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 06:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 07:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 07:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 08:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 08:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 09:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 09:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 10:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 10:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 11:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 11:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 12:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 12:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 13:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 13:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 14:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 14:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 15:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 15:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 16:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 16:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 17:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 17:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 18:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 18:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 19:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 19:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 20:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 20:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 21:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 21:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 22:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 22:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-28 23:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-28 23:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 00:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 00:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 01:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 01:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 02:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 02:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 03:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 03:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 04:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 04:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 05:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 05:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 06:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 06:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 07:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 07:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 08:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 08:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 09:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 09:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 10:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 10:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 11:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 11:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 12:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 12:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 13:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 13:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 14:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 14:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 15:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 15:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 16:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 16:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 17:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 17:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 18:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 18:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 19:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 19:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 20:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 20:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 21:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 21:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 22:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 22:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-29 23:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-29 23:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 00:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 00:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 01:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 01:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 02:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 02:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 03:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 03:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 04:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 04:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 05:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 05:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 06:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 06:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 07:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 07:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 08:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 08:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 09:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 09:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 10:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 10:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 11:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 11:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 12:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 12:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 13:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 13:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 14:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 14:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 15:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 15:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 16:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 16:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 17:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 17:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 18:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 18:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 19:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 19:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 20:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 20:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 21:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 21:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 22:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 22:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-06-30 23:00:00\n", - "week: 25\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '06-30 23:00:00+02:00') week: 25 stage: st0 duration: 0\n", - "date: 2030-07-01 00:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 00:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 01:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 01:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 02:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 02:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 03:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 03:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 04:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 04:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 05:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 05:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 06:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 06:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 07:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 07:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 08:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 08:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 09:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 09:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 10:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 10:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 11:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 11:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 12:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 12:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 13:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 13:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 14:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 14:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 15:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 15:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 16:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 16:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 17:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 17:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 18:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 18:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 19:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 19:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 20:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 20:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 21:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 21:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 22:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 22:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-01 23:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-01 23:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 00:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 00:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 01:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 01:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 02:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 02:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 03:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 03:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 04:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 04:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 05:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 05:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 06:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 06:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 07:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 07:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 08:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 08:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 09:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 09:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 10:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 10:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 11:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 11:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 12:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 12:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 13:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 13:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 14:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 14:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 15:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 15:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 16:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 16:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 17:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 17:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 18:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 18:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 19:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 19:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 20:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 20:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 21:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 21:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 22:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 22:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-02 23:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-02 23:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 00:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 00:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 01:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 01:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 02:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 02:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 03:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 03:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 04:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 04:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 05:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 05:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 06:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 06:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 07:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 07:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 08:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 08:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 09:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 09:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 10:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 10:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 11:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 11:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 12:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 12:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 13:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 13:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 14:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 14:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 15:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 15:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 16:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 16:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 17:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 17:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 18:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 18:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 19:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 19:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 20:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 20:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 21:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 21:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 22:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 22:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-03 23:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-03 23:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 00:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 00:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 01:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 01:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 02:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 02:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 03:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 03:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 04:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 04:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 05:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 05:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 06:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 06:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 07:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 07:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 08:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 08:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 09:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 09:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 10:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 10:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 11:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 11:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 12:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 12:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 13:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 13:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 14:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 14:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 15:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 15:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 16:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 16:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 17:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 17:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 18:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 18:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 19:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 19:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 20:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 20:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 21:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 21:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 22:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 22:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-04 23:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-04 23:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 00:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 00:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 01:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 01:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 02:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 02:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 03:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 03:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 04:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 04:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 05:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 05:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 06:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 06:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 07:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 07:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 08:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 08:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 09:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 09:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 10:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 10:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 11:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 11:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 12:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 12:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 13:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 13:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 14:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 14:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 15:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 15:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 16:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 16:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 17:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 17:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 18:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 18:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 19:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 19:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 20:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 20:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 21:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 21:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 22:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 22:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-05 23:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-05 23:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 00:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 00:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 01:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 01:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 02:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 02:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 03:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 03:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 04:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 04:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 05:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 05:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 06:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 06:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 07:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 07:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 08:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 08:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 09:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 09:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 10:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 10:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 11:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 11:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 12:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 12:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 13:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 13:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 14:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 14:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 15:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 15:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 16:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 16:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 17:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 17:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 18:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 18:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 19:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 19:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 20:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 20:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 21:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 21:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 22:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 22:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-06 23:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-06 23:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 00:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 00:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 01:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 01:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 02:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 02:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 03:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 03:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 04:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 04:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 05:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 05:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 06:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 06:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 07:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 07:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 08:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 08:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 09:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 09:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 10:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 10:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 11:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 11:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 12:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 12:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 13:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 13:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 14:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 14:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 15:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 15:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 16:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 16:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 17:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 17:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 18:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 18:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 19:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 19:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 20:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 20:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 21:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 21:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 22:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 22:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-07 23:00:00\n", - "week: 26\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-07 23:00:00+02:00') week: 26 stage: st0 duration: 0\n", - "date: 2030-07-08 00:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 00:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 01:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 01:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 02:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 02:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 03:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 03:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 04:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 04:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 05:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 05:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 06:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 06:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 07:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 07:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 08:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 08:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 09:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 09:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 10:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 10:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 11:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 11:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 12:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 12:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 13:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 13:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 14:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 14:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 15:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 15:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 16:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 16:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 17:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 17:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 18:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 18:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 19:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 19:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 20:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 20:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 21:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 21:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 22:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 22:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-08 23:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-08 23:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 00:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 00:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 01:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 01:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 02:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 02:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 03:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 03:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 04:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 04:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 05:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 05:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 06:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 06:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 07:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 07:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 08:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 08:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 09:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 09:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 10:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 10:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 11:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 11:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 12:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 12:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 13:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 13:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 14:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 14:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 15:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 15:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 16:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 16:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 17:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 17:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 18:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 18:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 19:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 19:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 20:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 20:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 21:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 21:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 22:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 22:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-09 23:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-09 23:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 00:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 00:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 01:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 01:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 02:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 02:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 03:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 03:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 04:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 04:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 05:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 05:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 06:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 06:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 07:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 07:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 08:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 08:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 09:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 09:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 10:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 10:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 11:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 11:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 12:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 12:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 13:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 13:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 14:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 14:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 15:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 15:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 16:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 16:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 17:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 17:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 18:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 18:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 19:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 19:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 20:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 20:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 21:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 21:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 22:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 22:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-10 23:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-10 23:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 00:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 00:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 01:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 01:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 02:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 02:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 03:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 03:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 04:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 04:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 05:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 05:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 06:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 06:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 07:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 07:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 08:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 08:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 09:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 09:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 10:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 10:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 11:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 11:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 12:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 12:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 13:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 13:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 14:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 14:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 15:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 15:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 16:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 16:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 17:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 17:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 18:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 18:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 19:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 19:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 20:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 20:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 21:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 21:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 22:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 22:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-11 23:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-11 23:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 00:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 00:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 01:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 01:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 02:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 02:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 03:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 03:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 04:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 04:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 05:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 05:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 06:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 06:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 07:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 07:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 08:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 08:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 09:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 09:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 10:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 10:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 11:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 11:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 12:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 12:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 13:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 13:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 14:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 14:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 15:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 15:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 16:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 16:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 17:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 17:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 18:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 18:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 19:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 19:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 20:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 20:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 21:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 21:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 22:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 22:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-12 23:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-12 23:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 00:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 00:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 01:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 01:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 02:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 02:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 03:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 03:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 04:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 04:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 05:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 05:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 06:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 06:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 07:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 07:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 08:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 08:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 09:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 09:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 10:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 10:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 11:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 11:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 12:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 12:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 13:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 13:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 14:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 14:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 15:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 15:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 16:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 16:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 17:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 17:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 18:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 18:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 19:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 19:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 20:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 20:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 21:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 21:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 22:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 22:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-13 23:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-13 23:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 00:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 00:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 01:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 01:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 02:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 02:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 03:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 03:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 04:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 04:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 05:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 05:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 06:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 06:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 07:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 07:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 08:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 08:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 09:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 09:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 10:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 10:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 11:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 11:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 12:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 12:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 13:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 13:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 14:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 14:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 15:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 15:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 16:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 16:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 17:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 17:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 18:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 18:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 19:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 19:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 20:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 20:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 21:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 21:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 22:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 22:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-14 23:00:00\n", - "week: 27\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-14 23:00:00+02:00') week: 27 stage: st0 duration: 0\n", - "date: 2030-07-15 00:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 00:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 01:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 01:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 02:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 02:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 03:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 03:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 04:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 04:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 05:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 05:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 06:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 06:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 07:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 07:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 08:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 08:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 09:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 09:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 10:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 10:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 11:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 11:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 12:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 12:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 13:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 13:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 14:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 14:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 15:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 15:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 16:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 16:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 17:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 17:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 18:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 18:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 19:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 19:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 20:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 20:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 21:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 21:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 22:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 22:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-15 23:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-15 23:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 00:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 00:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 01:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 01:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 02:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 02:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 03:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 03:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 04:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 04:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 05:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 05:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 06:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 06:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 07:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 07:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 08:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 08:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 09:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 09:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 10:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 10:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 11:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 11:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 12:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 12:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 13:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 13:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 14:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 14:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 15:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 15:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 16:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 16:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 17:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 17:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 18:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 18:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 19:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 19:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 20:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 20:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 21:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 21:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 22:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 22:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-16 23:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-16 23:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 00:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 00:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 01:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 01:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 02:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 02:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 03:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 03:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 04:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 04:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 05:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 05:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 06:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 06:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 07:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 07:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 08:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 08:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 09:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 09:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 10:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 10:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 11:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 11:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 12:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 12:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 13:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 13:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 14:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 14:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 15:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 15:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 16:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 16:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 17:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 17:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 18:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 18:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 19:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 19:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 20:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 20:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 21:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 21:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 22:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 22:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-17 23:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-17 23:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 00:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 00:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 01:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 01:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 02:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 02:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 03:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 03:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 04:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 04:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 05:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 05:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 06:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 06:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 07:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 07:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 08:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 08:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 09:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 09:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 10:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 10:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 11:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 11:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 12:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 12:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 13:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 13:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 14:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 14:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 15:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 15:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 16:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 16:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 17:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 17:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 18:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 18:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 19:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 19:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 20:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 20:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 21:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 21:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 22:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 22:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-18 23:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-18 23:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 00:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 00:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 01:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 01:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 02:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 02:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 03:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 03:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 04:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 04:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 05:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 05:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 06:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 06:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 07:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 07:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 08:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 08:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 09:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 09:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 10:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 10:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 11:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 11:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 12:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 12:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 13:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 13:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 14:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 14:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 15:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 15:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 16:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 16:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 17:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 17:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 18:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 18:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 19:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 19:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 20:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 20:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 21:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 21:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 22:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 22:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-19 23:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-19 23:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 00:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 00:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 01:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 01:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 02:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 02:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 03:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 03:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 04:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 04:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 05:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 05:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 06:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 06:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 07:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 07:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 08:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 08:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 09:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 09:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 10:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 10:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 11:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 11:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 12:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 12:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 13:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 13:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 14:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 14:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 15:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 15:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 16:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 16:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 17:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 17:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 18:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 18:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 19:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 19:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 20:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 20:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 21:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 21:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 22:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 22:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-20 23:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-20 23:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 00:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 00:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 01:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 01:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 02:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 02:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 03:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 03:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 04:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 04:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 05:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 05:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 06:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 06:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 07:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 07:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 08:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 08:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 09:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 09:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 10:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 10:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 11:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 11:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 12:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 12:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 13:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 13:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 14:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 14:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 15:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 15:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 16:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 16:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 17:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 17:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 18:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 18:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 19:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 19:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 20:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 20:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 21:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 21:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 22:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 22:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-21 23:00:00\n", - "week: 28\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-21 23:00:00+02:00') week: 28 stage: st0 duration: 0\n", - "date: 2030-07-22 00:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 00:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 01:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 01:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 02:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 02:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 03:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 03:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 04:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 04:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 05:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 05:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 06:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 06:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 07:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 07:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 08:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 08:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 09:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 09:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 10:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 10:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 11:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 11:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 12:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 12:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 13:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 13:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 14:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 14:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 15:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 15:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 16:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 16:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 17:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 17:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 18:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 18:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 19:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 19:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 20:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 20:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 21:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 21:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 22:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 22:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-22 23:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-22 23:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 00:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 00:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 01:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 01:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 02:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 02:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 03:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 03:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 04:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 04:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 05:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 05:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 06:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 06:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 07:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 07:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 08:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 08:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 09:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 09:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 10:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 10:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 11:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 11:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 12:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 12:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 13:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 13:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 14:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 14:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 15:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 15:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 16:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 16:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 17:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 17:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 18:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 18:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 19:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 19:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 20:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 20:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 21:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 21:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 22:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 22:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-23 23:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-23 23:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 00:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 00:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 01:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 01:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 02:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 02:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 03:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 03:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 04:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 04:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 05:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 05:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 06:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 06:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 07:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 07:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 08:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 08:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 09:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 09:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 10:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 10:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 11:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 11:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 12:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 12:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 13:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 13:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 14:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 14:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 15:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 15:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 16:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 16:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 17:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 17:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 18:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 18:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 19:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 19:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 20:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 20:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 21:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 21:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 22:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 22:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-24 23:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-24 23:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 00:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 00:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 01:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 01:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 02:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 02:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 03:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 03:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 04:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 04:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 05:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 05:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 06:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 06:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 07:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 07:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 08:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 08:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 09:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 09:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 10:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 10:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 11:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 11:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 12:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 12:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 13:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 13:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 14:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 14:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 15:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 15:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 16:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 16:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 17:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 17:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 18:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 18:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 19:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 19:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 20:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 20:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 21:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 21:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 22:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 22:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-25 23:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-25 23:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 00:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 00:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 01:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 01:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 02:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 02:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 03:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 03:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 04:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 04:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 05:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 05:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 06:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 06:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 07:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 07:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 08:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 08:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 09:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 09:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 10:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 10:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 11:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 11:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 12:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 12:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 13:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 13:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 14:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 14:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 15:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 15:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 16:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 16:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 17:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 17:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 18:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 18:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 19:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 19:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 20:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 20:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 21:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 21:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 22:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 22:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-26 23:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-26 23:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 00:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 00:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 01:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 01:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 02:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 02:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 03:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 03:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 04:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 04:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 05:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 05:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 06:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 06:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 07:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 07:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 08:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 08:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 09:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 09:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 10:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 10:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 11:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 11:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 12:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 12:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 13:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 13:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 14:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 14:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 15:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 15:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 16:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 16:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 17:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 17:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 18:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 18:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 19:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 19:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 20:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 20:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 21:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 21:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 22:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 22:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-27 23:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-27 23:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 00:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 00:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 01:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 01:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 02:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 02:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 03:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 03:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 04:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 04:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 05:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 05:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 06:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 06:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 07:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 07:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 08:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 08:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 09:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 09:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 10:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 10:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 11:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 11:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 12:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 12:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 13:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 13:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 14:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 14:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 15:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 15:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 16:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 16:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 17:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 17:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 18:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 18:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 19:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 19:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 20:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 20:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 21:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 21:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 22:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 22:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-28 23:00:00\n", - "week: 29\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-28 23:00:00+02:00') week: 29 stage: st0 duration: 0\n", - "date: 2030-07-29 00:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 00:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 01:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 01:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 02:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 02:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 03:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 03:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 04:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 04:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 05:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 05:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 06:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 06:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 07:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 07:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 08:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 08:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 09:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 09:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 10:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 10:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 11:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 11:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 12:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 12:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 13:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 13:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 14:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 14:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 15:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 15:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 16:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 16:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 17:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 17:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 18:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 18:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 19:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 19:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 20:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 20:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 21:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 21:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 22:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 22:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-29 23:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-29 23:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 00:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 00:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 01:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 01:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 02:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 02:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 03:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 03:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 04:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 04:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 05:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 05:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 06:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 06:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 07:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 07:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 08:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 08:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 09:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 09:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 10:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 10:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 11:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 11:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 12:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 12:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 13:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 13:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 14:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 14:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 15:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 15:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 16:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 16:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 17:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 17:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 18:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 18:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 19:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 19:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 20:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 20:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 21:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 21:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 22:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 22:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-30 23:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-30 23:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 00:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 00:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 01:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 01:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 02:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 02:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 03:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 03:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 04:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 04:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 05:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 05:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 06:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 06:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 07:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 07:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 08:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 08:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 09:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 09:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 10:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 10:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 11:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 11:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 12:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 12:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 13:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 13:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 14:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 14:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 15:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 15:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 16:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 16:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 17:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 17:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 18:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 18:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 19:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 19:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 20:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 20:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 21:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 21:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 22:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 22:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-07-31 23:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '07-31 23:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 00:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 00:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 01:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 01:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 02:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 02:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 03:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 03:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 04:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 04:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 05:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 05:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 06:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 06:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 07:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 07:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 08:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 08:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 09:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 09:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 10:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 10:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 11:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 11:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 12:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 12:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 13:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 13:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 14:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 14:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 15:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 15:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 16:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 16:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 17:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 17:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 18:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 18:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 19:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 19:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 20:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 20:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 21:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 21:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 22:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 22:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-01 23:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-01 23:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 00:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 00:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 01:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 01:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 02:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 02:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 03:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 03:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 04:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 04:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 05:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 05:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 06:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 06:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 07:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 07:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 08:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 08:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 09:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 09:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 10:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 10:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 11:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 11:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 12:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 12:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 13:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 13:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 14:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 14:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 15:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 15:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 16:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 16:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 17:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 17:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 18:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 18:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 19:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 19:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 20:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 20:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 21:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 21:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 22:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 22:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-02 23:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-02 23:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 00:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 00:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 01:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 01:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 02:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 02:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 03:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 03:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 04:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 04:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 05:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 05:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 06:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 06:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 07:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 07:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 08:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 08:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 09:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 09:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 10:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 10:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 11:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 11:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 12:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 12:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 13:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 13:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 14:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 14:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 15:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 15:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 16:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 16:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 17:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 17:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 18:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 18:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 19:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 19:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 20:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 20:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 21:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 21:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 22:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 22:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-03 23:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-03 23:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 00:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 00:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 01:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 01:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 02:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 02:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 03:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 03:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 04:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 04:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 05:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 05:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 06:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 06:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 07:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 07:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 08:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 08:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 09:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 09:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 10:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 10:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 11:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 11:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 12:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 12:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 13:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 13:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 14:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 14:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 15:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 15:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 16:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 16:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 17:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 17:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 18:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 18:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 19:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 19:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 20:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 20:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 21:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 21:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 22:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 22:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-04 23:00:00\n", - "week: 30\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-04 23:00:00+02:00') week: 30 stage: st0 duration: 0\n", - "date: 2030-08-05 00:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 00:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 01:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 01:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 02:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 02:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 03:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 03:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 04:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 04:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 05:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 05:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 06:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 06:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 07:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 07:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 08:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 08:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 09:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 09:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 10:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 10:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 11:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 11:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 12:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 12:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 13:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 13:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 14:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 14:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 15:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 15:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 16:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 16:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 17:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 17:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 18:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 18:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 19:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 19:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 20:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 20:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 21:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 21:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 22:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 22:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-05 23:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-05 23:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 00:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 00:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 01:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 01:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 02:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 02:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 03:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 03:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 04:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 04:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 05:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 05:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 06:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 06:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 07:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 07:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 08:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 08:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 09:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 09:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 10:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 10:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 11:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 11:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 12:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 12:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 13:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 13:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 14:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 14:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 15:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 15:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 16:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 16:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 17:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 17:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 18:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 18:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 19:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 19:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 20:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 20:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 21:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 21:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 22:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 22:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-06 23:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-06 23:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 00:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 00:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 01:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 01:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 02:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 02:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 03:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 03:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 04:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 04:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 05:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 05:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 06:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 06:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 07:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 07:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 08:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 08:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 09:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 09:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 10:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 10:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 11:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 11:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 12:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 12:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 13:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 13:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 14:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 14:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 15:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 15:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 16:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 16:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 17:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 17:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 18:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 18:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 19:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 19:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 20:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 20:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 21:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 21:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 22:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 22:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-07 23:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-07 23:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 00:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 00:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 01:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 01:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 02:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 02:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 03:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 03:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 04:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 04:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 05:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 05:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 06:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 06:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 07:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 07:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 08:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 08:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 09:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 09:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 10:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 10:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 11:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 11:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 12:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 12:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 13:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 13:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 14:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 14:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 15:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 15:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 16:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 16:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 17:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 17:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 18:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 18:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 19:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 19:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 20:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 20:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 21:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 21:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 22:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 22:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-08 23:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-08 23:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 00:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 00:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 01:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 01:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 02:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 02:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 03:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 03:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 04:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 04:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 05:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 05:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 06:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 06:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 07:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 07:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 08:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 08:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 09:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 09:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 10:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 10:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 11:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 11:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 12:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 12:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 13:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 13:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 14:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 14:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 15:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 15:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 16:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 16:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 17:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 17:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 18:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 18:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 19:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 19:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 20:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 20:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 21:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 21:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 22:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 22:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-09 23:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-09 23:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 00:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 00:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 01:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 01:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 02:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 02:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 03:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 03:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 04:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 04:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 05:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 05:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 06:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 06:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 07:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 07:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 08:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 08:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 09:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 09:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 10:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 10:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 11:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 11:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 12:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 12:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 13:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 13:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 14:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 14:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 15:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 15:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 16:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 16:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 17:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 17:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 18:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 18:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 19:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 19:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 20:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 20:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 21:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 21:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 22:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 22:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-10 23:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-10 23:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 00:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 00:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 01:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 01:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 02:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 02:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 03:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 03:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 04:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 04:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 05:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 05:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 06:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 06:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 07:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 07:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 08:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 08:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 09:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 09:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 10:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 10:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 11:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 11:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 12:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 12:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 13:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 13:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 14:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 14:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 15:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 15:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 16:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 16:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 17:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 17:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 18:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 18:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 19:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 19:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 20:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 20:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 21:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 21:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 22:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 22:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-11 23:00:00\n", - "week: 31\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-11 23:00:00+02:00') week: 31 stage: st0 duration: 0\n", - "date: 2030-08-12 00:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 00:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 01:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 01:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 02:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 02:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 03:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 03:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 04:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 04:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 05:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 05:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 06:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 06:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 07:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 07:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 08:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 08:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 09:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 09:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 10:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 10:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 11:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 11:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 12:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 12:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 13:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 13:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 14:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 14:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 15:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 15:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 16:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 16:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 17:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 17:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 18:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 18:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 19:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 19:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 20:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 20:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 21:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 21:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 22:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 22:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-12 23:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-12 23:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 00:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 00:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 01:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 01:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 02:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 02:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 03:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 03:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 04:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 04:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 05:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 05:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 06:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 06:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 07:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 07:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 08:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 08:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 09:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 09:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 10:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 10:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 11:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 11:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 12:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 12:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 13:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 13:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 14:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 14:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 15:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 15:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 16:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 16:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 17:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 17:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 18:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 18:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 19:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 19:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 20:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 20:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 21:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 21:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 22:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 22:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-13 23:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-13 23:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 00:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 00:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 01:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 01:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 02:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 02:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 03:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 03:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 04:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 04:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 05:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 05:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 06:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 06:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 07:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 07:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 08:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 08:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 09:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 09:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 10:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 10:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 11:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 11:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 12:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 12:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 13:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 13:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 14:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 14:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 15:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 15:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 16:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 16:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 17:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 17:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 18:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 18:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 19:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 19:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 20:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 20:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 21:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 21:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 22:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 22:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-14 23:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-14 23:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 00:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 00:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 01:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 01:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 02:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 02:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 03:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 03:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 04:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 04:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 05:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 05:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 06:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 06:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 07:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 07:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 08:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 08:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 09:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 09:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 10:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 10:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 11:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 11:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 12:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 12:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 13:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 13:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 14:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 14:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 15:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 15:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 16:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 16:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 17:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 17:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 18:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 18:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 19:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 19:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 20:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 20:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 21:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 21:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 22:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 22:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-15 23:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-15 23:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 00:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 00:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 01:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 01:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 02:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 02:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 03:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 03:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 04:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 04:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 05:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 05:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 06:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 06:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 07:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 07:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 08:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 08:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 09:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 09:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 10:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 10:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 11:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 11:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 12:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 12:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 13:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 13:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 14:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 14:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 15:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 15:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 16:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 16:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 17:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 17:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 18:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 18:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 19:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 19:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 20:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 20:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 21:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 21:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 22:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 22:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-16 23:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-16 23:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 00:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 00:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 01:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 01:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 02:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 02:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 03:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 03:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 04:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 04:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 05:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 05:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 06:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 06:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 07:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 07:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 08:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 08:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 09:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 09:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 10:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 10:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 11:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 11:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 12:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 12:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 13:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 13:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 14:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 14:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 15:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 15:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 16:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 16:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 17:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 17:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 18:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 18:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 19:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 19:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 20:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 20:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 21:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 21:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 22:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 22:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-17 23:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-17 23:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 00:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 00:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 01:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 01:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 02:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 02:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 03:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 03:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 04:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 04:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 05:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 05:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 06:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 06:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 07:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 07:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 08:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 08:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 09:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 09:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 10:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 10:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 11:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 11:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 12:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 12:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 13:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 13:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 14:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 14:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 15:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 15:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 16:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 16:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 17:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 17:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 18:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 18:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 19:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 19:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 20:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 20:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 21:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 21:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 22:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 22:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-18 23:00:00\n", - "week: 32\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-18 23:00:00+02:00') week: 32 stage: st0 duration: 0\n", - "date: 2030-08-19 00:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 00:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 01:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 01:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 02:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 02:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 03:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 03:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 04:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 04:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 05:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 05:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 06:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 06:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 07:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 07:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 08:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 08:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 09:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 09:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 10:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 10:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 11:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 11:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 12:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 12:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 13:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 13:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 14:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 14:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 15:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 15:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 16:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 16:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 17:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 17:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 18:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 18:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 19:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 19:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 20:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 20:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 21:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 21:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 22:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 22:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-19 23:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-19 23:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 00:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 00:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 01:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 01:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 02:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 02:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 03:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 03:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 04:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 04:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 05:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 05:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 06:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 06:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 07:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 07:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 08:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 08:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 09:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 09:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 10:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 10:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 11:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 11:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 12:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 12:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 13:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 13:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 14:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 14:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 15:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 15:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 16:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 16:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 17:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 17:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 18:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 18:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 19:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 19:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 20:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 20:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 21:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 21:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 22:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 22:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-20 23:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-20 23:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 00:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 00:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 01:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 01:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 02:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 02:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 03:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 03:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 04:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 04:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 05:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 05:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 06:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 06:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 07:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 07:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 08:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 08:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 09:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 09:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 10:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 10:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 11:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 11:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 12:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 12:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 13:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 13:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 14:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 14:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 15:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 15:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 16:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 16:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 17:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 17:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 18:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 18:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 19:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 19:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 20:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 20:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 21:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 21:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 22:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 22:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-21 23:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-21 23:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 00:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 00:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 01:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 01:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 02:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 02:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 03:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 03:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 04:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 04:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 05:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 05:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 06:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 06:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 07:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 07:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 08:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 08:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 09:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 09:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 10:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 10:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 11:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 11:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 12:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 12:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 13:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 13:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 14:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 14:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 15:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 15:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 16:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 16:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 17:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 17:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 18:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 18:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 19:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 19:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 20:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 20:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 21:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 21:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 22:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 22:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-22 23:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-22 23:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 00:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 00:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 01:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 01:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 02:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 02:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 03:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 03:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 04:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 04:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 05:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 05:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 06:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 06:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 07:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 07:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 08:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 08:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 09:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 09:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 10:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 10:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 11:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 11:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 12:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 12:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 13:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 13:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 14:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 14:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 15:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 15:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 16:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 16:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 17:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 17:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 18:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 18:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 19:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 19:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 20:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 20:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 21:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 21:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 22:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 22:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-23 23:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-23 23:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 00:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 00:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 01:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 01:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 02:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 02:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 03:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 03:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 04:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 04:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 05:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 05:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 06:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 06:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 07:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 07:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 08:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 08:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 09:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 09:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 10:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 10:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 11:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 11:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 12:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 12:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 13:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 13:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 14:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 14:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 15:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 15:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 16:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 16:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 17:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 17:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 18:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 18:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 19:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 19:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 20:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 20:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 21:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 21:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 22:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 22:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-24 23:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-24 23:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 00:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 00:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 01:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 01:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 02:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 02:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 03:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 03:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 04:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 04:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 05:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 05:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 06:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 06:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 07:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 07:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 08:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 08:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 09:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 09:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 10:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 10:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 11:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 11:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 12:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 12:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 13:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 13:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 14:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 14:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 15:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 15:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 16:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 16:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 17:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 17:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 18:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 18:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 19:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 19:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 20:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 20:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 21:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 21:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 22:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 22:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-25 23:00:00\n", - "week: 33\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-25 23:00:00+02:00') week: 33 stage: st0 duration: 0\n", - "date: 2030-08-26 00:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 00:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 01:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 01:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 02:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 02:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 03:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 03:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 04:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 04:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 05:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 05:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 06:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 06:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 07:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 07:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 08:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 08:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 09:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 09:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 10:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 10:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 11:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 11:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 12:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 12:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 13:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 13:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 14:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 14:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 15:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 15:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 16:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 16:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 17:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 17:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 18:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 18:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 19:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 19:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 20:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 20:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 21:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 21:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 22:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 22:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-26 23:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-26 23:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 00:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 00:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 01:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 01:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 02:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 02:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 03:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 03:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 04:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 04:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 05:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 05:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 06:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 06:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 07:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 07:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 08:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 08:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 09:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 09:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 10:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 10:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 11:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 11:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 12:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 12:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 13:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 13:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 14:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 14:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 15:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 15:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 16:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 16:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 17:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 17:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 18:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 18:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 19:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 19:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 20:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 20:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 21:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 21:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 22:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 22:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-27 23:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-27 23:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 00:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 00:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 01:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 01:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 02:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 02:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 03:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 03:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 04:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 04:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 05:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 05:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 06:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 06:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 07:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 07:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 08:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 08:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 09:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 09:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 10:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 10:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 11:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 11:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 12:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 12:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 13:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 13:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 14:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 14:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 15:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 15:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 16:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 16:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 17:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 17:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 18:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 18:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 19:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 19:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 20:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 20:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 21:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 21:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 22:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 22:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-28 23:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-28 23:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 00:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 00:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 01:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 01:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 02:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 02:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 03:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 03:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 04:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 04:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 05:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 05:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 06:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 06:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 07:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 07:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 08:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 08:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 09:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 09:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 10:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 10:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 11:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 11:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 12:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 12:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 13:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 13:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 14:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 14:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 15:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 15:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 16:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 16:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 17:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 17:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 18:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 18:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 19:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 19:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 20:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 20:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 21:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 21:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 22:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 22:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-29 23:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-29 23:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 00:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 00:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 01:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 01:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 02:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 02:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 03:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 03:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 04:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 04:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 05:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 05:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 06:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 06:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 07:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 07:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 08:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 08:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 09:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 09:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 10:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 10:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 11:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 11:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 12:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 12:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 13:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 13:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 14:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 14:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 15:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 15:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 16:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 16:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 17:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 17:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 18:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 18:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 19:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 19:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 20:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 20:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 21:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 21:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 22:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 22:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-30 23:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-30 23:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 00:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 00:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 01:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 01:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 02:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 02:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 03:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 03:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 04:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 04:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 05:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 05:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 06:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 06:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 07:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 07:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 08:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 08:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 09:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 09:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 10:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 10:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 11:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 11:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 12:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 12:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 13:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 13:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 14:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 14:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 15:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 15:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 16:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 16:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 17:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 17:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 18:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 18:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 19:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 19:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 20:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 20:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 21:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 21:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 22:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 22:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-08-31 23:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '08-31 23:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 00:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 00:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 01:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 01:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 02:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 02:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 03:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 03:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 04:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 04:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 05:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 05:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 06:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 06:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 07:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 07:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 08:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 08:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 09:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 09:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 10:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 10:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 11:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 11:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 12:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 12:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 13:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 13:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 14:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 14:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 15:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 15:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 16:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 16:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 17:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 17:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 18:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 18:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 19:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 19:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 20:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 20:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 21:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 21:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 22:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 22:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-01 23:00:00\n", - "week: 34\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-01 23:00:00+02:00') week: 34 stage: st0 duration: 0\n", - "date: 2030-09-02 00:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 00:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 01:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 01:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 02:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 02:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 03:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 03:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 04:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 04:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 05:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 05:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 06:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 06:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 07:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 07:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 08:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 08:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 09:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 09:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 10:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 10:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 11:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 11:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 12:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 12:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 13:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 13:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 14:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 14:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 15:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 15:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 16:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 16:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 17:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 17:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 18:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 18:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 19:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 19:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 20:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 20:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 21:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 21:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 22:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 22:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-02 23:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-02 23:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 00:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 00:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 01:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 01:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 02:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 02:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 03:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 03:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 04:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 04:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 05:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 05:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 06:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 06:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 07:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 07:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 08:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 08:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 09:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 09:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 10:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 10:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 11:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 11:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 12:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 12:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 13:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 13:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 14:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 14:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 15:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 15:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 16:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 16:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 17:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 17:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 18:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 18:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 19:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 19:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 20:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 20:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 21:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 21:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 22:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 22:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-03 23:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-03 23:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 00:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 00:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 01:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 01:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 02:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 02:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 03:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 03:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 04:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 04:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 05:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 05:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 06:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 06:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 07:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 07:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 08:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 08:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 09:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 09:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 10:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 10:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 11:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 11:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 12:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 12:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 13:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 13:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 14:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 14:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 15:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 15:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 16:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 16:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 17:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 17:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 18:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 18:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 19:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 19:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 20:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 20:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 21:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 21:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 22:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 22:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-04 23:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-04 23:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 00:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 00:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 01:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 01:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 02:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 02:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 03:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 03:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 04:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 04:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 05:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 05:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 06:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 06:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 07:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 07:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 08:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 08:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 09:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 09:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 10:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 10:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 11:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 11:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 12:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 12:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 13:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 13:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 14:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 14:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 15:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 15:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 16:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 16:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 17:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 17:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 18:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 18:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 19:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 19:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 20:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 20:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 21:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 21:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 22:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 22:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-05 23:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-05 23:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 00:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 00:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 01:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 01:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 02:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 02:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 03:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 03:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 04:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 04:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 05:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 05:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 06:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 06:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 07:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 07:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 08:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 08:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 09:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 09:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 10:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 10:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 11:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 11:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 12:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 12:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 13:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 13:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 14:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 14:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 15:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 15:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 16:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 16:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 17:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 17:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 18:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 18:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 19:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 19:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 20:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 20:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 21:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 21:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 22:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 22:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-06 23:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-06 23:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 00:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 00:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 01:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 01:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 02:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 02:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 03:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 03:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 04:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 04:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 05:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 05:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 06:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 06:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 07:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 07:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 08:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 08:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 09:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 09:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 10:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 10:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 11:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 11:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 12:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 12:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 13:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 13:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 14:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 14:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 15:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 15:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 16:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 16:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 17:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 17:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 18:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 18:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 19:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 19:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 20:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 20:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 21:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 21:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 22:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 22:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-07 23:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-07 23:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 00:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 00:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 01:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 01:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 02:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 02:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 03:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 03:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 04:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 04:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 05:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 05:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 06:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 06:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 07:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 07:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 08:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 08:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 09:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 09:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 10:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 10:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 11:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 11:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 12:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 12:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 13:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 13:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 14:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 14:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 15:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 15:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 16:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 16:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 17:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 17:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 18:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 18:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 19:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 19:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 20:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 20:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 21:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 21:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 22:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 22:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-08 23:00:00\n", - "week: 35\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-08 23:00:00+02:00') week: 35 stage: st0 duration: 0\n", - "date: 2030-09-09 00:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 00:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 01:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 01:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 02:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 02:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 03:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 03:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 04:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 04:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 05:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 05:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 06:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 06:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 07:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 07:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 08:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 08:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 09:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 09:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 10:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 10:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 11:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 11:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 12:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 12:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 13:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 13:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 14:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 14:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 15:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 15:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 16:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 16:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 17:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 17:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 18:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 18:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 19:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 19:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 20:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 20:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 21:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 21:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 22:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 22:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-09 23:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-09 23:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 00:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 00:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 01:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 01:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 02:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 02:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 03:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 03:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 04:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 04:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 05:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 05:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 06:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 06:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 07:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 07:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 08:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 08:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 09:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 09:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 10:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 10:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 11:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 11:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 12:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 12:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 13:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 13:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 14:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 14:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 15:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 15:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 16:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 16:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 17:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 17:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 18:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 18:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 19:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 19:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 20:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 20:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 21:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 21:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 22:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 22:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-10 23:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-10 23:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 00:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 00:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 01:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 01:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 02:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 02:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 03:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 03:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 04:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 04:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 05:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 05:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 06:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 06:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 07:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 07:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 08:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 08:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 09:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 09:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 10:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 10:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 11:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 11:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 12:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 12:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 13:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 13:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 14:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 14:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 15:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 15:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 16:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 16:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 17:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 17:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 18:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 18:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 19:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 19:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 20:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 20:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 21:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 21:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 22:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 22:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-11 23:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-11 23:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 00:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 00:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 01:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 01:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 02:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 02:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 03:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 03:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 04:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 04:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 05:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 05:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 06:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 06:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 07:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 07:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 08:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 08:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 09:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 09:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 10:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 10:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 11:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 11:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 12:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 12:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 13:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 13:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 14:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 14:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 15:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 15:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 16:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 16:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 17:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 17:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 18:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 18:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 19:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 19:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 20:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 20:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 21:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 21:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 22:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 22:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-12 23:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-12 23:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 00:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 00:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 01:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 01:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 02:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 02:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 03:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 03:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 04:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 04:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 05:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 05:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 06:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 06:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 07:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 07:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 08:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 08:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 09:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 09:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 10:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 10:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 11:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 11:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 12:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 12:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 13:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 13:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 14:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 14:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 15:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 15:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 16:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 16:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 17:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 17:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 18:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 18:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 19:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 19:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 20:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 20:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 21:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 21:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 22:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 22:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-13 23:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-13 23:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 00:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 00:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 01:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 01:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 02:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 02:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 03:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 03:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 04:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 04:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 05:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 05:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 06:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 06:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 07:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 07:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 08:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 08:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 09:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 09:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 10:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 10:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 11:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 11:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 12:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 12:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 13:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 13:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 14:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 14:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 15:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 15:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 16:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 16:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 17:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 17:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 18:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 18:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 19:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 19:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 20:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 20:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 21:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 21:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 22:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 22:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-14 23:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-14 23:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 00:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 00:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 01:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 01:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 02:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 02:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 03:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 03:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 04:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 04:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 05:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 05:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 06:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 06:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 07:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 07:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 08:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 08:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 09:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 09:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 10:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 10:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 11:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 11:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 12:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 12:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 13:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 13:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 14:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 14:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 15:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 15:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 16:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 16:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 17:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 17:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 18:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 18:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 19:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 19:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 20:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 20:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 21:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 21:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 22:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 22:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-15 23:00:00\n", - "week: 36\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-15 23:00:00+02:00') week: 36 stage: st0 duration: 0\n", - "date: 2030-09-16 00:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 00:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 01:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 01:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 02:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 02:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 03:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 03:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 04:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 04:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 05:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 05:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 06:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 06:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 07:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 07:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 08:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 08:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 09:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 09:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 10:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 10:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 11:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 11:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 12:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 12:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 13:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 13:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 14:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 14:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 15:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 15:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 16:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 16:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 17:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 17:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 18:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 18:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 19:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 19:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 20:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 20:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 21:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 21:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 22:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 22:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-16 23:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-16 23:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 00:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 00:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 01:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 01:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 02:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 02:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 03:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 03:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 04:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 04:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 05:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 05:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 06:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 06:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 07:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 07:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 08:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 08:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 09:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 09:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 10:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 10:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 11:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 11:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 12:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 12:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 13:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 13:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 14:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 14:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 15:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 15:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 16:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 16:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 17:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 17:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 18:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 18:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 19:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 19:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 20:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 20:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 21:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 21:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 22:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 22:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-17 23:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-17 23:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 00:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 00:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 01:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 01:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 02:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 02:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 03:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 03:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 04:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 04:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 05:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 05:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 06:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 06:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 07:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 07:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 08:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 08:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 09:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 09:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 10:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 10:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 11:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 11:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 12:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 12:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 13:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 13:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 14:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 14:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 15:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 15:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 16:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 16:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 17:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 17:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 18:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 18:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 19:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 19:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 20:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 20:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 21:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 21:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 22:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 22:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-18 23:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-18 23:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 00:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 00:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 01:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 01:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 02:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 02:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 03:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 03:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 04:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 04:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 05:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 05:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 06:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 06:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 07:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 07:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 08:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 08:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 09:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 09:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 10:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 10:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 11:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 11:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 12:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 12:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 13:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 13:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 14:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 14:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 15:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 15:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 16:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 16:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 17:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 17:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 18:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 18:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 19:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 19:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 20:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 20:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 21:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 21:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 22:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 22:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-19 23:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-19 23:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 00:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 00:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 01:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 01:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 02:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 02:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 03:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 03:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 04:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 04:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 05:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 05:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 06:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 06:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 07:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 07:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 08:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 08:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 09:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 09:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 10:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 10:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 11:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 11:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 12:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 12:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 13:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 13:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 14:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 14:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 15:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 15:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 16:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 16:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 17:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 17:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 18:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 18:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 19:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 19:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 20:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 20:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 21:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 21:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 22:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 22:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-20 23:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-20 23:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 00:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 00:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 01:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 01:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 02:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 02:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 03:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 03:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 04:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 04:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 05:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 05:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 06:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 06:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 07:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 07:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 08:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 08:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 09:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 09:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 10:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 10:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 11:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 11:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 12:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 12:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 13:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 13:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 14:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 14:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 15:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 15:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 16:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 16:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 17:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 17:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 18:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 18:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 19:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 19:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 20:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 20:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 21:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 21:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 22:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 22:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-21 23:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-21 23:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 00:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 00:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 01:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 01:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 02:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 02:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 03:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 03:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 04:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 04:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 05:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 05:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 06:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 06:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 07:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 07:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 08:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 08:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 09:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 09:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 10:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 10:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 11:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 11:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 12:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 12:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 13:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 13:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 14:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 14:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 15:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 15:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 16:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 16:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 17:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 17:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 18:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 18:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 19:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 19:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 20:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 20:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 21:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 21:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 22:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 22:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-22 23:00:00\n", - "week: 37\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-22 23:00:00+02:00') week: 37 stage: st0 duration: 0\n", - "date: 2030-09-23 00:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 00:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 01:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 01:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 02:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 02:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 03:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 03:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 04:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 04:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 05:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 05:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 06:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 06:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 07:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 07:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 08:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 08:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 09:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 09:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 10:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 10:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 11:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 11:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 12:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 12:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 13:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 13:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 14:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 14:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 15:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 15:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 16:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 16:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 17:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 17:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 18:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 18:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 19:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 19:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 20:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 20:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 21:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 21:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 22:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 22:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-23 23:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-23 23:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 00:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 00:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 01:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 01:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 02:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 02:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 03:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 03:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 04:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 04:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 05:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 05:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 06:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 06:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 07:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 07:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 08:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 08:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 09:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 09:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 10:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 10:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 11:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 11:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 12:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 12:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 13:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 13:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 14:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 14:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 15:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 15:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 16:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 16:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 17:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 17:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 18:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 18:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 19:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 19:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 20:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 20:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 21:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 21:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 22:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 22:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-24 23:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-24 23:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 00:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 00:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 01:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 01:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 02:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 02:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 03:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 03:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 04:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 04:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 05:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 05:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 06:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 06:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 07:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 07:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 08:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 08:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 09:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 09:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 10:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 10:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 11:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 11:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 12:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 12:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 13:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 13:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 14:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 14:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 15:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 15:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 16:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 16:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 17:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 17:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 18:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 18:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 19:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 19:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 20:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 20:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 21:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 21:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 22:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 22:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-25 23:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-25 23:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 00:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 00:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 01:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 01:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 02:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 02:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 03:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 03:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 04:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 04:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 05:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 05:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 06:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 06:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 07:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 07:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 08:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 08:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 09:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 09:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 10:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 10:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 11:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 11:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 12:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 12:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 13:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 13:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 14:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 14:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 15:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 15:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 16:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 16:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 17:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 17:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 18:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 18:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 19:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 19:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 20:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 20:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 21:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 21:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 22:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 22:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-26 23:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-26 23:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 00:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 00:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 01:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 01:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 02:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 02:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 03:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 03:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 04:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 04:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 05:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 05:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 06:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 06:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 07:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 07:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 08:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 08:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 09:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 09:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 10:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 10:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 11:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 11:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 12:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 12:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 13:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 13:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 14:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 14:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 15:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 15:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 16:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 16:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 17:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 17:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 18:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 18:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 19:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 19:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 20:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 20:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 21:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 21:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 22:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 22:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-27 23:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-27 23:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 00:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 00:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 01:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 01:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 02:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 02:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 03:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 03:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 04:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 04:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 05:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 05:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 06:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 06:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 07:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 07:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 08:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 08:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 09:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 09:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 10:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 10:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 11:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 11:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 12:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 12:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 13:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 13:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 14:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 14:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 15:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 15:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 16:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 16:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 17:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 17:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 18:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 18:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 19:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 19:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 20:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 20:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 21:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 21:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 22:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 22:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-28 23:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-28 23:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 00:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 00:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 01:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 01:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 02:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 02:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 03:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 03:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 04:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 04:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 05:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 05:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 06:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 06:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 07:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 07:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 08:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 08:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 09:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 09:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 10:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 10:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 11:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 11:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 12:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 12:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 13:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 13:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 14:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 14:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 15:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 15:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 16:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 16:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 17:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 17:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 18:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 18:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 19:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 19:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 20:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 20:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 21:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 21:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 22:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 22:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-29 23:00:00\n", - "week: 38\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-29 23:00:00+02:00') week: 38 stage: st0 duration: 0\n", - "date: 2030-09-30 00:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 00:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 01:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 01:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 02:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 02:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 03:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 03:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 04:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 04:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 05:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 05:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 06:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 06:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 07:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 07:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 08:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 08:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 09:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 09:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 10:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 10:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 11:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 11:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 12:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 12:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 13:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 13:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 14:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 14:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 15:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 15:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 16:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 16:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 17:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 17:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 18:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 18:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 19:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 19:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 20:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 20:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 21:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 21:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 22:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 22:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-09-30 23:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '09-30 23:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 00:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 00:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 01:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 01:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 02:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 02:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 03:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 03:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 04:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 04:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 05:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 05:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 06:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 06:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 07:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 07:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 08:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 08:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 09:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 09:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 10:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 10:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 11:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 11:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 12:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 12:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 13:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 13:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 14:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 14:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 15:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 15:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 16:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 16:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 17:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 17:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 18:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 18:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 19:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 19:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 20:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 20:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 21:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 21:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 22:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 22:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-01 23:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-01 23:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 00:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 00:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 01:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 01:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 02:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 02:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 03:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 03:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 04:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 04:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 05:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 05:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 06:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 06:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 07:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 07:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 08:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 08:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 09:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 09:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 10:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 10:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 11:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 11:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 12:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 12:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 13:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 13:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 14:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 14:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 15:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 15:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 16:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 16:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 17:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 17:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 18:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 18:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 19:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 19:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 20:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 20:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 21:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 21:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 22:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 22:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-02 23:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-02 23:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 00:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 00:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 01:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 01:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 02:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 02:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 03:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 03:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 04:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 04:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 05:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 05:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 06:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 06:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 07:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 07:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 08:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 08:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 09:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 09:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 10:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 10:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 11:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 11:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 12:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 12:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 13:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 13:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 14:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 14:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 15:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 15:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 16:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 16:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 17:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 17:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 18:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 18:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 19:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 19:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 20:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 20:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 21:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 21:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 22:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 22:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-03 23:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-03 23:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 00:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 00:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 01:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 01:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 02:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 02:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 03:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 03:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 04:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 04:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 05:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 05:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 06:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 06:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 07:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 07:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 08:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 08:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 09:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 09:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 10:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 10:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 11:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 11:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 12:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 12:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 13:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 13:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 14:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 14:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 15:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 15:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 16:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 16:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 17:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 17:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 18:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 18:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 19:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 19:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 20:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 20:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 21:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 21:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 22:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 22:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-04 23:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-04 23:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 00:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 00:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 01:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 01:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 02:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 02:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 03:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 03:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 04:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 04:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 05:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 05:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 06:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 06:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 07:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 07:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 08:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 08:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 09:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 09:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 10:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 10:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 11:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 11:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 12:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 12:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 13:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 13:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 14:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 14:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 15:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 15:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 16:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 16:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 17:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 17:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 18:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 18:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 19:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 19:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 20:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 20:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 21:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 21:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 22:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 22:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-05 23:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-05 23:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 00:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 00:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 01:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 01:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 02:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 02:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 03:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 03:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 04:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 04:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 05:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 05:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 06:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 06:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 07:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 07:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 08:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 08:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 09:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 09:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 10:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 10:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 11:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 11:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 12:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 12:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 13:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 13:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 14:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 14:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 15:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 15:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 16:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 16:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 17:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 17:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 18:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 18:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 19:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 19:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 20:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 20:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 21:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 21:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 22:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 22:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-06 23:00:00\n", - "week: 39\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-06 23:00:00+02:00') week: 39 stage: st0 duration: 0\n", - "date: 2030-10-07 00:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 00:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 01:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 01:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 02:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 02:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 03:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 03:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 04:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 04:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 05:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 05:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 06:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 06:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 07:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 07:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 08:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 08:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 09:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 09:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 10:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 10:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 11:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 11:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 12:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 12:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 13:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 13:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 14:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 14:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 15:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 15:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 16:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 16:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 17:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 17:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 18:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 18:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 19:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 19:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 20:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 20:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 21:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 21:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 22:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 22:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-07 23:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-07 23:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 00:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 00:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 01:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 01:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 02:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 02:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 03:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 03:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 04:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 04:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 05:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 05:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 06:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 06:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 07:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 07:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 08:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 08:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 09:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 09:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 10:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 10:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 11:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 11:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 12:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 12:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 13:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 13:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 14:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 14:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 15:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 15:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 16:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 16:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 17:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 17:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 18:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 18:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 19:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 19:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 20:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 20:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 21:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 21:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 22:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 22:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-08 23:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-08 23:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 00:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 00:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 01:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 01:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 02:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 02:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 03:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 03:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 04:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 04:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 05:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 05:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 06:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 06:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 07:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 07:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 08:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 08:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 09:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 09:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 10:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 10:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 11:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 11:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 12:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 12:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 13:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 13:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 14:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 14:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 15:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 15:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 16:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 16:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 17:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 17:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 18:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 18:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 19:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 19:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 20:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 20:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 21:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 21:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 22:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 22:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-09 23:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-09 23:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 00:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 00:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 01:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 01:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 02:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 02:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 03:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 03:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 04:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 04:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 05:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 05:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 06:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 06:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 07:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 07:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 08:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 08:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 09:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 09:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 10:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 10:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 11:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 11:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 12:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 12:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 13:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 13:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 14:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 14:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 15:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 15:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 16:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 16:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 17:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 17:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 18:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 18:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 19:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 19:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 20:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 20:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 21:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 21:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 22:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 22:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-10 23:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-10 23:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 00:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 00:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 01:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 01:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 02:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 02:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 03:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 03:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 04:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 04:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 05:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 05:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 06:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 06:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 07:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 07:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 08:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 08:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 09:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 09:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 10:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 10:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 11:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 11:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 12:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 12:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 13:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 13:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 14:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 14:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 15:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 15:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 16:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 16:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 17:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 17:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 18:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 18:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 19:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 19:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 20:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 20:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 21:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 21:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 22:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 22:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-11 23:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-11 23:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 00:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 00:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 01:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 01:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 02:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 02:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 03:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 03:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 04:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 04:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 05:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 05:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 06:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 06:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 07:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 07:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 08:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 08:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 09:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 09:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 10:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 10:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 11:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 11:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 12:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 12:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 13:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 13:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 14:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 14:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 15:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 15:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 16:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 16:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 17:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 17:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 18:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 18:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 19:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 19:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 20:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 20:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 21:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 21:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 22:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 22:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-12 23:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-12 23:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 00:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 00:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 01:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 01:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 02:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 02:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 03:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 03:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 04:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 04:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 05:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 05:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 06:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 06:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 07:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 07:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 08:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 08:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 09:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 09:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 10:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 10:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 11:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 11:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 12:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 12:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 13:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 13:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 14:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 14:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 15:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 15:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 16:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 16:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 17:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 17:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 18:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 18:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 19:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 19:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 20:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 20:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 21:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 21:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 22:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 22:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-13 23:00:00\n", - "week: 40\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-13 23:00:00+02:00') week: 40 stage: st0 duration: 0\n", - "date: 2030-10-14 00:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 00:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 01:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 01:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 02:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 02:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 03:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 03:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 04:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 04:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 05:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 05:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 06:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 06:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 07:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 07:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 08:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 08:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 09:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 09:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 10:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 10:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 11:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 11:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 12:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 12:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 13:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 13:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 14:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 14:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 15:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 15:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 16:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 16:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 17:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 17:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 18:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 18:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 19:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 19:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 20:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 20:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 21:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 21:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 22:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 22:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-14 23:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-14 23:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 00:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 00:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 01:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 01:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 02:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 02:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 03:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 03:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 04:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 04:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 05:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 05:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 06:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 06:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 07:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 07:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 08:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 08:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 09:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 09:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 10:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 10:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 11:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 11:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 12:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 12:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 13:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 13:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 14:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 14:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 15:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 15:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 16:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 16:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 17:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 17:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 18:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 18:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 19:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 19:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 20:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 20:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 21:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 21:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 22:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 22:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-15 23:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-15 23:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 00:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 00:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 01:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 01:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 02:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 02:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 03:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 03:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 04:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 04:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 05:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 05:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 06:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 06:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 07:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 07:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 08:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 08:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 09:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 09:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 10:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 10:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 11:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 11:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 12:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 12:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 13:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 13:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 14:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 14:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 15:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 15:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 16:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 16:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 17:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 17:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 18:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 18:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 19:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 19:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 20:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 20:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 21:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 21:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 22:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 22:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-16 23:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-16 23:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 00:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 00:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 01:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 01:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 02:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 02:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 03:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 03:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 04:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 04:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 05:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 05:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 06:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 06:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 07:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 07:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 08:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 08:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 09:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 09:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 10:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 10:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 11:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 11:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 12:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 12:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 13:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 13:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 14:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 14:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 15:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 15:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 16:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 16:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 17:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 17:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 18:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 18:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 19:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 19:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 20:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 20:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 21:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 21:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 22:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 22:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-17 23:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-17 23:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 00:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 00:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 01:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 01:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 02:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 02:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 03:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 03:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 04:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 04:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 05:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 05:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 06:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 06:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 07:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 07:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 08:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 08:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 09:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 09:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 10:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 10:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 11:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 11:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 12:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 12:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 13:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 13:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 14:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 14:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 15:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 15:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 16:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 16:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 17:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 17:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 18:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 18:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 19:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 19:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 20:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 20:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 21:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 21:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 22:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 22:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-18 23:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-18 23:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 00:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 00:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 01:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 01:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 02:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 02:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 03:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 03:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 04:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 04:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 05:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 05:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 06:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 06:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 07:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 07:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 08:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 08:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 09:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 09:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 10:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 10:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 11:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 11:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 12:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 12:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 13:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 13:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 14:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 14:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 15:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 15:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 16:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 16:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 17:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 17:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 18:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 18:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 19:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 19:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 20:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 20:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 21:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 21:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 22:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 22:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-19 23:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-19 23:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 00:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 00:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 01:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 01:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 02:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 02:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 03:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 03:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 04:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 04:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 05:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 05:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 06:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 06:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 07:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 07:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 08:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 08:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 09:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 09:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 10:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 10:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 11:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 11:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 12:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 12:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 13:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 13:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 14:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 14:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 15:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 15:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 16:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 16:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 17:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 17:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 18:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 18:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 19:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 19:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 20:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 20:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 21:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 21:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 22:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 22:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-20 23:00:00\n", - "week: 41\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-20 23:00:00+02:00') week: 41 stage: st0 duration: 0\n", - "date: 2030-10-21 00:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 00:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 01:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 01:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 02:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 02:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 03:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 03:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 04:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 04:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 05:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 05:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 06:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 06:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 07:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 07:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 08:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 08:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 09:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 09:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 10:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 10:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 11:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 11:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 12:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 12:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 13:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 13:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 14:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 14:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 15:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 15:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 16:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 16:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 17:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 17:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 18:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 18:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 19:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 19:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 20:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 20:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 21:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 21:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 22:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 22:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-21 23:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-21 23:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 00:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 00:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 01:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 01:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 02:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 02:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 03:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 03:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 04:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 04:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 05:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 05:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 06:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 06:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 07:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 07:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 08:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 08:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 09:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 09:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 10:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 10:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 11:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 11:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 12:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 12:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 13:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 13:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 14:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 14:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 15:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 15:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 16:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 16:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 17:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 17:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 18:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 18:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 19:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 19:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 20:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 20:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 21:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 21:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 22:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 22:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-22 23:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-22 23:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 00:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 00:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 01:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 01:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 02:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 02:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 03:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 03:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 04:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 04:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 05:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 05:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 06:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 06:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 07:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 07:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 08:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 08:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 09:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 09:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 10:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 10:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 11:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 11:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 12:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 12:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 13:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 13:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 14:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 14:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 15:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 15:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 16:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 16:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 17:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 17:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 18:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 18:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 19:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 19:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 20:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 20:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 21:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 21:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 22:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 22:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-23 23:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-23 23:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 00:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 00:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 01:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 01:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 02:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 02:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 03:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 03:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 04:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 04:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 05:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 05:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 06:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 06:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 07:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 07:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 08:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 08:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 09:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 09:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 10:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 10:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 11:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 11:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 12:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 12:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 13:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 13:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 14:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 14:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 15:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 15:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 16:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 16:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 17:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 17:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 18:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 18:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 19:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 19:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 20:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 20:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 21:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 21:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 22:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 22:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-24 23:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-24 23:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 00:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 00:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 01:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 01:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 02:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 02:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 03:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 03:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 04:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 04:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 05:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 05:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 06:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 06:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 07:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 07:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 08:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 08:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 09:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 09:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 10:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 10:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 11:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 11:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 12:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 12:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 13:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 13:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 14:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 14:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 15:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 15:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 16:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 16:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 17:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 17:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 18:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 18:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 19:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 19:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 20:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 20:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 21:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 21:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 22:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 22:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-25 23:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-25 23:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 00:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 00:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 01:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 01:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 02:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 02:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 03:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 03:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 04:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 04:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 05:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 05:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 06:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 06:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 07:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 07:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 08:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 08:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 09:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 09:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 10:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 10:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 11:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 11:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 12:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 12:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 13:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 13:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 14:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 14:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 15:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 15:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 16:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 16:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 17:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 17:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 18:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 18:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 19:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 19:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 20:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 20:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 21:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 21:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 22:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 22:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-26 23:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-26 23:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 00:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 00:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 01:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 01:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 02:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 02:00:00+02:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 03:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 03:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 04:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 04:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 05:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 05:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 06:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 06:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 07:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 07:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 08:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 08:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 09:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 09:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 10:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 10:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 11:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 11:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 12:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 12:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 13:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 13:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 14:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 14:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 15:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 15:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 16:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 16:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 17:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 17:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 18:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 18:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 19:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 19:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 20:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 20:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 21:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 21:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 22:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 22:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-27 23:00:00\n", - "week: 42\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-27 23:00:00+01:00') week: 42 stage: st0 duration: 0\n", - "date: 2030-10-28 00:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 00:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 01:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 01:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 02:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 02:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 03:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 03:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 04:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 04:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 05:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 05:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 06:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 06:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 07:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 07:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 08:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 08:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 09:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 09:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 10:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 10:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 11:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 11:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 12:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 12:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 13:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 13:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 14:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 14:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 15:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 15:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 16:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 16:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 17:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 17:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 18:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 18:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 19:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 19:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 20:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 20:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 21:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 21:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 22:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 22:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-28 23:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-28 23:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 00:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 00:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 01:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 01:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 02:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 02:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 03:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 03:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 04:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 04:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 05:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 05:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 06:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 06:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 07:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 07:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 08:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 08:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 09:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 09:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 10:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 10:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 11:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 11:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 12:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 12:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 13:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 13:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 14:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 14:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 15:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 15:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 16:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 16:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 17:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 17:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 18:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 18:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 19:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 19:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 20:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 20:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 21:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 21:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 22:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 22:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-29 23:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-29 23:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 00:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 00:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 01:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 01:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 02:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 02:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 03:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 03:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 04:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 04:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 05:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 05:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 06:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 06:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 07:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 07:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 08:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 08:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 09:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 09:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 10:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 10:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 11:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 11:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 12:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 12:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 13:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 13:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 14:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 14:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 15:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 15:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 16:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 16:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 17:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 17:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 18:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 18:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 19:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 19:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 20:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 20:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 21:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 21:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 22:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 22:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-30 23:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-30 23:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 00:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 00:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 01:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 01:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 02:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 02:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 03:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 03:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 04:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 04:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 05:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 05:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 06:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 06:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 07:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 07:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 08:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 08:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 09:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 09:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 10:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 10:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 11:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 11:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 12:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 12:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 13:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 13:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 14:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 14:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 15:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 15:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 16:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 16:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 17:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 17:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 18:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 18:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 19:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 19:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 20:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 20:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 21:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 21:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 22:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 22:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-10-31 23:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '10-31 23:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 00:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 00:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 01:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 01:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 02:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 02:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 03:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 03:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 04:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 04:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 05:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 05:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 06:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 06:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 07:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 07:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 08:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 08:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 09:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 09:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 10:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 10:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 11:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 11:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 12:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 12:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 13:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 13:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 14:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 14:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 15:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 15:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 16:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 16:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 17:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 17:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 18:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 18:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 19:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 19:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 20:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 20:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 21:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 21:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 22:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 22:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-01 23:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-01 23:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 00:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 00:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 01:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 01:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 02:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 02:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 03:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 03:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 04:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 04:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 05:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 05:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 06:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 06:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 07:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 07:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 08:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 08:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 09:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 09:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 10:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 10:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 11:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 11:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 12:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 12:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 13:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 13:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 14:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 14:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 15:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 15:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 16:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 16:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 17:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 17:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 18:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 18:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 19:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 19:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 20:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 20:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 21:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 21:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 22:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 22:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-02 23:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-02 23:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 00:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 00:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 01:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 01:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 02:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 02:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 03:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 03:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 04:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 04:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 05:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 05:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 06:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 06:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 07:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 07:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 08:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 08:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 09:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 09:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 10:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 10:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 11:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 11:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 12:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 12:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 13:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 13:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 14:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 14:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 15:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 15:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 16:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 16:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 17:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 17:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 18:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 18:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 19:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 19:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 20:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 20:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 21:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 21:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 22:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 22:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-03 23:00:00\n", - "week: 43\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-03 23:00:00+01:00') week: 43 stage: st0 duration: 0\n", - "date: 2030-11-04 00:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 00:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 01:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 01:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 02:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 02:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 03:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 03:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 04:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 04:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 05:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 05:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 06:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 06:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 07:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 07:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 08:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 08:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 09:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 09:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 10:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 10:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 11:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 11:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 12:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 12:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 13:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 13:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 14:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 14:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 15:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 15:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 16:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 16:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 17:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 17:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 18:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 18:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 19:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 19:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 20:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 20:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 21:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 21:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 22:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 22:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-04 23:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-04 23:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 00:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 00:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 01:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 01:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 02:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 02:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 03:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 03:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 04:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 04:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 05:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 05:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 06:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 06:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 07:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 07:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 08:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 08:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 09:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 09:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 10:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 10:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 11:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 11:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 12:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 12:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 13:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 13:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 14:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 14:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 15:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 15:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 16:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 16:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 17:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 17:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 18:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 18:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 19:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 19:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 20:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 20:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 21:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 21:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 22:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 22:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-05 23:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-05 23:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 00:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 00:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 01:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 01:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 02:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 02:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 03:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 03:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 04:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 04:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 05:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 05:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 06:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 06:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 07:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 07:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 08:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 08:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 09:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 09:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 10:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 10:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 11:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 11:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 12:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 12:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 13:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 13:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 14:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 14:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 15:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 15:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 16:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 16:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 17:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 17:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 18:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 18:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 19:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 19:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 20:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 20:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 21:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 21:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 22:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 22:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-06 23:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-06 23:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 00:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 00:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 01:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 01:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 02:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 02:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 03:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 03:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 04:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 04:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 05:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 05:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 06:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 06:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 07:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 07:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 08:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 08:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 09:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 09:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 10:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 10:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 11:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 11:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 12:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 12:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 13:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 13:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 14:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 14:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 15:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 15:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 16:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 16:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 17:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 17:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 18:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 18:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 19:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 19:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 20:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 20:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 21:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 21:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 22:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 22:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-07 23:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-07 23:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 00:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 00:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 01:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 01:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 02:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 02:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 03:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 03:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 04:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 04:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 05:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 05:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 06:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 06:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 07:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 07:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 08:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 08:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 09:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 09:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 10:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 10:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 11:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 11:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 12:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 12:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 13:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 13:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 14:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 14:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 15:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 15:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 16:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 16:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 17:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 17:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 18:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 18:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 19:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 19:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 20:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 20:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 21:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 21:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 22:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 22:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-08 23:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-08 23:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 00:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 00:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 01:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 01:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 02:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 02:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 03:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 03:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 04:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 04:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 05:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 05:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 06:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 06:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 07:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 07:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 08:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 08:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 09:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 09:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 10:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 10:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 11:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 11:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 12:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 12:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 13:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 13:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 14:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 14:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 15:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 15:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 16:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 16:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 17:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 17:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 18:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 18:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 19:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 19:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 20:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 20:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 21:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 21:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 22:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 22:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-09 23:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-09 23:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 00:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 00:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 01:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 01:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 02:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 02:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 03:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 03:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 04:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 04:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 05:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 05:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 06:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 06:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 07:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 07:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 08:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 08:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 09:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 09:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 10:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 10:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 11:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 11:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 12:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 12:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 13:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 13:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 14:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 14:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 15:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 15:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 16:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 16:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 17:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 17:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 18:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 18:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 19:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 19:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 20:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 20:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 21:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 21:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 22:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 22:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-10 23:00:00\n", - "week: 44\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-10 23:00:00+01:00') week: 44 stage: st0 duration: 0\n", - "date: 2030-11-11 00:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 00:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 01:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 01:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 02:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 02:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 03:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 03:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 04:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 04:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 05:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 05:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 06:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 06:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 07:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 07:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 08:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 08:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 09:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 09:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 10:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 10:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 11:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 11:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 12:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 12:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 13:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 13:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 14:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 14:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 15:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 15:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 16:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 16:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 17:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 17:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 18:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 18:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 19:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 19:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 20:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 20:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 21:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 21:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 22:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 22:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-11 23:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-11 23:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 00:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 00:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 01:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 01:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 02:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 02:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 03:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 03:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 04:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 04:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 05:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 05:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 06:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 06:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 07:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 07:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 08:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 08:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 09:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 09:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 10:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 10:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 11:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 11:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 12:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 12:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 13:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 13:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 14:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 14:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 15:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 15:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 16:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 16:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 17:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 17:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 18:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 18:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 19:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 19:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 20:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 20:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 21:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 21:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 22:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 22:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-12 23:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-12 23:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 00:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 00:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 01:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 01:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 02:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 02:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 03:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 03:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 04:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 04:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 05:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 05:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 06:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 06:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 07:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 07:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 08:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 08:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 09:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 09:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 10:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 10:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 11:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 11:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 12:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 12:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 13:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 13:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 14:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 14:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 15:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 15:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 16:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 16:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 17:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 17:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 18:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 18:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 19:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 19:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 20:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 20:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 21:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 21:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 22:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 22:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-13 23:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-13 23:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 00:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 00:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 01:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 01:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 02:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 02:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 03:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 03:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 04:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 04:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 05:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 05:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 06:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 06:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 07:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 07:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 08:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 08:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 09:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 09:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 10:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 10:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 11:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 11:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 12:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 12:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 13:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 13:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 14:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 14:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 15:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 15:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 16:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 16:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 17:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 17:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 18:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 18:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 19:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 19:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 20:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 20:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 21:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 21:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 22:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 22:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-14 23:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-14 23:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 00:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 00:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 01:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 01:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 02:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 02:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 03:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 03:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 04:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 04:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 05:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 05:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 06:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 06:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 07:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 07:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 08:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 08:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 09:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 09:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 10:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 10:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 11:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 11:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 12:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 12:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 13:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 13:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 14:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 14:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 15:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 15:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 16:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 16:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 17:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 17:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 18:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 18:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 19:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 19:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 20:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 20:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 21:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 21:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 22:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 22:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-15 23:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-15 23:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 00:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 00:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 01:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 01:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 02:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 02:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 03:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 03:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 04:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 04:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 05:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 05:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 06:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 06:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 07:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 07:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 08:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 08:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 09:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 09:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 10:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 10:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 11:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 11:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 12:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 12:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 13:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 13:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 14:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 14:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 15:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 15:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 16:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 16:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 17:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 17:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 18:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 18:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 19:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 19:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 20:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 20:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 21:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 21:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 22:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 22:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-16 23:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-16 23:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 00:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 00:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 01:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 01:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 02:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 02:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 03:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 03:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 04:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 04:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 05:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 05:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 06:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 06:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 07:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 07:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 08:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 08:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 09:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 09:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 10:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 10:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 11:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 11:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 12:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 12:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 13:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 13:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 14:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 14:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 15:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 15:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 16:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 16:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 17:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 17:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 18:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 18:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 19:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 19:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 20:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 20:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 21:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 21:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 22:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 22:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-17 23:00:00\n", - "week: 45\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-17 23:00:00+01:00') week: 45 stage: st0 duration: 0\n", - "date: 2030-11-18 00:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 00:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 01:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 01:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 02:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 02:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 03:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 03:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 04:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 04:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 05:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 05:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 06:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 06:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 07:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 07:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 08:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 08:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 09:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 09:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 10:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 10:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 11:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 11:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 12:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 12:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 13:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 13:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 14:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 14:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 15:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 15:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 16:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 16:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 17:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 17:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 18:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 18:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 19:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 19:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 20:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 20:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 21:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 21:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 22:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 22:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-18 23:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-18 23:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 00:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 00:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 01:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 01:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 02:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 02:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 03:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 03:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 04:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 04:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 05:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 05:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 06:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 06:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 07:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 07:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 08:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 08:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 09:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 09:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 10:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 10:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 11:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 11:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 12:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 12:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 13:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 13:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 14:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 14:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 15:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 15:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 16:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 16:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 17:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 17:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 18:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 18:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 19:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 19:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 20:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 20:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 21:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 21:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 22:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 22:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-19 23:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-19 23:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 00:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 00:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 01:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 01:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 02:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 02:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 03:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 03:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 04:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 04:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 05:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 05:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 06:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 06:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 07:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 07:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 08:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 08:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 09:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 09:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 10:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 10:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 11:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 11:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 12:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 12:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 13:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 13:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 14:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 14:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 15:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 15:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 16:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 16:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 17:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 17:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 18:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 18:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 19:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 19:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 20:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 20:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 21:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 21:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 22:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 22:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-20 23:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-20 23:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 00:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 00:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 01:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 01:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 02:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 02:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 03:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 03:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 04:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 04:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 05:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 05:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 06:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 06:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 07:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 07:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 08:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 08:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 09:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 09:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 10:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 10:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 11:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 11:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 12:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 12:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 13:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 13:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 14:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 14:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 15:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 15:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 16:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 16:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 17:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 17:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 18:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 18:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 19:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 19:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 20:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 20:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 21:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 21:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 22:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 22:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-21 23:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-21 23:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 00:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 00:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 01:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 01:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 02:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 02:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 03:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 03:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 04:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 04:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 05:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 05:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 06:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 06:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 07:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 07:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 08:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 08:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 09:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 09:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 10:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 10:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 11:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 11:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 12:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 12:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 13:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 13:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 14:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 14:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 15:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 15:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 16:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 16:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 17:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 17:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 18:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 18:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 19:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 19:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 20:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 20:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 21:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 21:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 22:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 22:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-22 23:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-22 23:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 00:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 00:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 01:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 01:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 02:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 02:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 03:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 03:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 04:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 04:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 05:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 05:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 06:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 06:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 07:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 07:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 08:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 08:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 09:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 09:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 10:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 10:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 11:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 11:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 12:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 12:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 13:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 13:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 14:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 14:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 15:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 15:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 16:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 16:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 17:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 17:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 18:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 18:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 19:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 19:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 20:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 20:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 21:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 21:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 22:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 22:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-23 23:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-23 23:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 00:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 00:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 01:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 01:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 02:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 02:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 03:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 03:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 04:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 04:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 05:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 05:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 06:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 06:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 07:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 07:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 08:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 08:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 09:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 09:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 10:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 10:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 11:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 11:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 12:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 12:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 13:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 13:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 14:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 14:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 15:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 15:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 16:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 16:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 17:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 17:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 18:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 18:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 19:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 19:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 20:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 20:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 21:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 21:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 22:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 22:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-24 23:00:00\n", - "week: 46\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-24 23:00:00+01:00') week: 46 stage: st0 duration: 0\n", - "date: 2030-11-25 00:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 00:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 01:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 01:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 02:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 02:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 03:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 03:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 04:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 04:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 05:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 05:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 06:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 06:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 07:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 07:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 08:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 08:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 09:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 09:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 10:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 10:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 11:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 11:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 12:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 12:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 13:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 13:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 14:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 14:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 15:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 15:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 16:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 16:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 17:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 17:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 18:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 18:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 19:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 19:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 20:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 20:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 21:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 21:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 22:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 22:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-25 23:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-25 23:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 00:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 00:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 01:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 01:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 02:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 02:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 03:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 03:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 04:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 04:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 05:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 05:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 06:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 06:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 07:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 07:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 08:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 08:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 09:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 09:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 10:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 10:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 11:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 11:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 12:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 12:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 13:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 13:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 14:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 14:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 15:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 15:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 16:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 16:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 17:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 17:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 18:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 18:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 19:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 19:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 20:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 20:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 21:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 21:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 22:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 22:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-26 23:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-26 23:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 00:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 00:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 01:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 01:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 02:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 02:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 03:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 03:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 04:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 04:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 05:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 05:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 06:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 06:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 07:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 07:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 08:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 08:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 09:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 09:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 10:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 10:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 11:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 11:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 12:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 12:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 13:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 13:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 14:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 14:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 15:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 15:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 16:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 16:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 17:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 17:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 18:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 18:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 19:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 19:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 20:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 20:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 21:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 21:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 22:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 22:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-27 23:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-27 23:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 00:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 00:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 01:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 01:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 02:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 02:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 03:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 03:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 04:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 04:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 05:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 05:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 06:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 06:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 07:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 07:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 08:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 08:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 09:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 09:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 10:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 10:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 11:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 11:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 12:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 12:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 13:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 13:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 14:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 14:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 15:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 15:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 16:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 16:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 17:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 17:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 18:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 18:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 19:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 19:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 20:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 20:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 21:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 21:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 22:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 22:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-28 23:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-28 23:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 00:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 00:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 01:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 01:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 02:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 02:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 03:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 03:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 04:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 04:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 05:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 05:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 06:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 06:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 07:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 07:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 08:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 08:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 09:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 09:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 10:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 10:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 11:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 11:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 12:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 12:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 13:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 13:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 14:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 14:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 15:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 15:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 16:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 16:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 17:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 17:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 18:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 18:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 19:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 19:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 20:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 20:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 21:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 21:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 22:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 22:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-29 23:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-29 23:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 00:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 00:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 01:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 01:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 02:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 02:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 03:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 03:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 04:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 04:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 05:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 05:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 06:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 06:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 07:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 07:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 08:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 08:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 09:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 09:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 10:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 10:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 11:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 11:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 12:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 12:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 13:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 13:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 14:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 14:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 15:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 15:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 16:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 16:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 17:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 17:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 18:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 18:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 19:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 19:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 20:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 20:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 21:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 21:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 22:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 22:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-11-30 23:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '11-30 23:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 00:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 00:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 01:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 01:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 02:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 02:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 03:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 03:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 04:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 04:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 05:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 05:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 06:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 06:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 07:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 07:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 08:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 08:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 09:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 09:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 10:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 10:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 11:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 11:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 12:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 12:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 13:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 13:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 14:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 14:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 15:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 15:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 16:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 16:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 17:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 17:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 18:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 18:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 19:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 19:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 20:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 20:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 21:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 21:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 22:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 22:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-01 23:00:00\n", - "week: 47\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-01 23:00:00+01:00') week: 47 stage: st0 duration: 0\n", - "date: 2030-12-02 00:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 00:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 01:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 01:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 02:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 02:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 03:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 03:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 04:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 04:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 05:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 05:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 06:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 06:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 07:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 07:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 08:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 08:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 09:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 09:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 10:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 10:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 11:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 11:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 12:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 12:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 13:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 13:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 14:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 14:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 15:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 15:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 16:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 16:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 17:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 17:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 18:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 18:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 19:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 19:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 20:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 20:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 21:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 21:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 22:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 22:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-02 23:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-02 23:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 00:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 00:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 01:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 01:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 02:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 02:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 03:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 03:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 04:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 04:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 05:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 05:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 06:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 06:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 07:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 07:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 08:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 08:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 09:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 09:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 10:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 10:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 11:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 11:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 12:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 12:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 13:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 13:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 14:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 14:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 15:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 15:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 16:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 16:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 17:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 17:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 18:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 18:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 19:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 19:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 20:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 20:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 21:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 21:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 22:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 22:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-03 23:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-03 23:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 00:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 00:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 01:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 01:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 02:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 02:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 03:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 03:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 04:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 04:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 05:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 05:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 06:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 06:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 07:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 07:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 08:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 08:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 09:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 09:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 10:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 10:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 11:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 11:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 12:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 12:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 13:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 13:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 14:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 14:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 15:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 15:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 16:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 16:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 17:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 17:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 18:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 18:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 19:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 19:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 20:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 20:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 21:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 21:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 22:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 22:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-04 23:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-04 23:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 00:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 00:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 01:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 01:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 02:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 02:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 03:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 03:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 04:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 04:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 05:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 05:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 06:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 06:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 07:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 07:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 08:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 08:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 09:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 09:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 10:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 10:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 11:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 11:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 12:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 12:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 13:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 13:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 14:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 14:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 15:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 15:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 16:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 16:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 17:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 17:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 18:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 18:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 19:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 19:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 20:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 20:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 21:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 21:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 22:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 22:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-05 23:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-05 23:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 00:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 00:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 01:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 01:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 02:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 02:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 03:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 03:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 04:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 04:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 05:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 05:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 06:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 06:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 07:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 07:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 08:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 08:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 09:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 09:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 10:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 10:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 11:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 11:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 12:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 12:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 13:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 13:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 14:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 14:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 15:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 15:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 16:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 16:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 17:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 17:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 18:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 18:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 19:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 19:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 20:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 20:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 21:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 21:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 22:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 22:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-06 23:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-06 23:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 00:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 00:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 01:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 01:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 02:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 02:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 03:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 03:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 04:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 04:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 05:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 05:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 06:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 06:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 07:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 07:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 08:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 08:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 09:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 09:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 10:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 10:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 11:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 11:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 12:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 12:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 13:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 13:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 14:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 14:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 15:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 15:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 16:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 16:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 17:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 17:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 18:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 18:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 19:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 19:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 20:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 20:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 21:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 21:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 22:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 22:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-07 23:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-07 23:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 00:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 00:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 01:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 01:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 02:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 02:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 03:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 03:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 04:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 04:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 05:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 05:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 06:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 06:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 07:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 07:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 08:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 08:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 09:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 09:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 10:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 10:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 11:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 11:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 12:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 12:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 13:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 13:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 14:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 14:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 15:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 15:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 16:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 16:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 17:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 17:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 18:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 18:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 19:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 19:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 20:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 20:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 21:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 21:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 22:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 22:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-08 23:00:00\n", - "week: 48\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-08 23:00:00+01:00') week: 48 stage: st0 duration: 0\n", - "date: 2030-12-09 00:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 00:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 01:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 01:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 02:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 02:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 03:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 03:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 04:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 04:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 05:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 05:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 06:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 06:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 07:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 07:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 08:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 08:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 09:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 09:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 10:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 10:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 11:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 11:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 12:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 12:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 13:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 13:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 14:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 14:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 15:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 15:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 16:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 16:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 17:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 17:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 18:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 18:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 19:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 19:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 20:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 20:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 21:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 21:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 22:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 22:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-09 23:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-09 23:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 00:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 00:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 01:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 01:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 02:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 02:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 03:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 03:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 04:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 04:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 05:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 05:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 06:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 06:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 07:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 07:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 08:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 08:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 09:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 09:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 10:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 10:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 11:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 11:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 12:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 12:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 13:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 13:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 14:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 14:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 15:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 15:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 16:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 16:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 17:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 17:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 18:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 18:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 19:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 19:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 20:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 20:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 21:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 21:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 22:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 22:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-10 23:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-10 23:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 00:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 00:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 01:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 01:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 02:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 02:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 03:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 03:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 04:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 04:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 05:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 05:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 06:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 06:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 07:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 07:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 08:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 08:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 09:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 09:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 10:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 10:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 11:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 11:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 12:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 12:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 13:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 13:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 14:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 14:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 15:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 15:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 16:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 16:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 17:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 17:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 18:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 18:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 19:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 19:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 20:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 20:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 21:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 21:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 22:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 22:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-11 23:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-11 23:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 00:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 00:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 01:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 01:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 02:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 02:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 03:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 03:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 04:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 04:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 05:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 05:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 06:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 06:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 07:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 07:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 08:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 08:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 09:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 09:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 10:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 10:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 11:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 11:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 12:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 12:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 13:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 13:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 14:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 14:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 15:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 15:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 16:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 16:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 17:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 17:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 18:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 18:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 19:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 19:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 20:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 20:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 21:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 21:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 22:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 22:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-12 23:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-12 23:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 00:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 00:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 01:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 01:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 02:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 02:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 03:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 03:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 04:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 04:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 05:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 05:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 06:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 06:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 07:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 07:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 08:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 08:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 09:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 09:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 10:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 10:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 11:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 11:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 12:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 12:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 13:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 13:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 14:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 14:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 15:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 15:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 16:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 16:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 17:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 17:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 18:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 18:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 19:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 19:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 20:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 20:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 21:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 21:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 22:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 22:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-13 23:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-13 23:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 00:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 00:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 01:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 01:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 02:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 02:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 03:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 03:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 04:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 04:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 05:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 05:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 06:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 06:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 07:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 07:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 08:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 08:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 09:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 09:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 10:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 10:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 11:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 11:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 12:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 12:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 13:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 13:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 14:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 14:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 15:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 15:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 16:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 16:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 17:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 17:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 18:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 18:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 19:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 19:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 20:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 20:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 21:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 21:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 22:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 22:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-14 23:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-14 23:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 00:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 00:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 01:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 01:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 02:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 02:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 03:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 03:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 04:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 04:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 05:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 05:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 06:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 06:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 07:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 07:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 08:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 08:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 09:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 09:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 10:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 10:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 11:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 11:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 12:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 12:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 13:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 13:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 14:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 14:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 15:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 15:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 16:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 16:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 17:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 17:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 18:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 18:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 19:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 19:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 20:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 20:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 21:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 21:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 22:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 22:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-15 23:00:00\n", - "week: 49\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-15 23:00:00+01:00') week: 49 stage: st0 duration: 0\n", - "date: 2030-12-16 00:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 00:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 01:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 01:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 02:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 02:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 03:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 03:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 04:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 04:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 05:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 05:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 06:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 06:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 07:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 07:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 08:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 08:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 09:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 09:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 10:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 10:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 11:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 11:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 12:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 12:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 13:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 13:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 14:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 14:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 15:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 15:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 16:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 16:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 17:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 17:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 18:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 18:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 19:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 19:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 20:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 20:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 21:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 21:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 22:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 22:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-16 23:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-16 23:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 00:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 00:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 01:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 01:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 02:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 02:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 03:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 03:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 04:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 04:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 05:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 05:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 06:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 06:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 07:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 07:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 08:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 08:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 09:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 09:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 10:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 10:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 11:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 11:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 12:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 12:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 13:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 13:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 14:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 14:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 15:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 15:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 16:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 16:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 17:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 17:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 18:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 18:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 19:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 19:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 20:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 20:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 21:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 21:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 22:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 22:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-17 23:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-17 23:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 00:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 00:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 01:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 01:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 02:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 02:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 03:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 03:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 04:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 04:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 05:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 05:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 06:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 06:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 07:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 07:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 08:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 08:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 09:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 09:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 10:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 10:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 11:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 11:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 12:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 12:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 13:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 13:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 14:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 14:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 15:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 15:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 16:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 16:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 17:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 17:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 18:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 18:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 19:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 19:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 20:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 20:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 21:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 21:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 22:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 22:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-18 23:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-18 23:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 00:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 00:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 01:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 01:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 02:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 02:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 03:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 03:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 04:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 04:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 05:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 05:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 06:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 06:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 07:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 07:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 08:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 08:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 09:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 09:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 10:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 10:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 11:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 11:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 12:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 12:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 13:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 13:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 14:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 14:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 15:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 15:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 16:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 16:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 17:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 17:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 18:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 18:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 19:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 19:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 20:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 20:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 21:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 21:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 22:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 22:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-19 23:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-19 23:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 00:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 00:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 01:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 01:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 02:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 02:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 03:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 03:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 04:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 04:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 05:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 05:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 06:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 06:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 07:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 07:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 08:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 08:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 09:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 09:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 10:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 10:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 11:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 11:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 12:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 12:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 13:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 13:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 14:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 14:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 15:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 15:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 16:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 16:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 17:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 17:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 18:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 18:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 19:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 19:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 20:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 20:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 21:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 21:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 22:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 22:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-20 23:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-20 23:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 00:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 00:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 01:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 01:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 02:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 02:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 03:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 03:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 04:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 04:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 05:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 05:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 06:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 06:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 07:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 07:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 08:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 08:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 09:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 09:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 10:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 10:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 11:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 11:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 12:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 12:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 13:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 13:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 14:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 14:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 15:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 15:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 16:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 16:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 17:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 17:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 18:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 18:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 19:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 19:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 20:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 20:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 21:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 21:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 22:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 22:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-21 23:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-21 23:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 00:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 00:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 01:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 01:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 02:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 02:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 03:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 03:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 04:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 04:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 05:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 05:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 06:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 06:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 07:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 07:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 08:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 08:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 09:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 09:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 10:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 10:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 11:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 11:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 12:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 12:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 13:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 13:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 14:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 14:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 15:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 15:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 16:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 16:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 17:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 17:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 18:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 18:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 19:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 19:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 20:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 20:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 21:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 21:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 22:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 22:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-22 23:00:00\n", - "week: 50\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-22 23:00:00+01:00') week: 50 stage: st0 duration: 0\n", - "date: 2030-12-23 00:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 00:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 01:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 01:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 02:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 02:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 03:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 03:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 04:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 04:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 05:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 05:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 06:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 06:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 07:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 07:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 08:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 08:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 09:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 09:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 10:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 10:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 11:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 11:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 12:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 12:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 13:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 13:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 14:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 14:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 15:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 15:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 16:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 16:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 17:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 17:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 18:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 18:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 19:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 19:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 20:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 20:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 21:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 21:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 22:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 22:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-23 23:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-23 23:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 00:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 00:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 01:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 01:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 02:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 02:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 03:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 03:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 04:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 04:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 05:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 05:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 06:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 06:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 07:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 07:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 08:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 08:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 09:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 09:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 10:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 10:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 11:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 11:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 12:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 12:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 13:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 13:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 14:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 14:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 15:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 15:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 16:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 16:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 17:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 17:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 18:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 18:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 19:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 19:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 20:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 20:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 21:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 21:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 22:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 22:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-24 23:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-24 23:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 00:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 00:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 01:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 01:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 02:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 02:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 03:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 03:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 04:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 04:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 05:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 05:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 06:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 06:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 07:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 07:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 08:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 08:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 09:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 09:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 10:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 10:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 11:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 11:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 12:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 12:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 13:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 13:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 14:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 14:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 15:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 15:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 16:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 16:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 17:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 17:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 18:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 18:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 19:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 19:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 20:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 20:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 21:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 21:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 22:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 22:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-25 23:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-25 23:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 00:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 00:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 01:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 01:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 02:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 02:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 03:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 03:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 04:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 04:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 05:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 05:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 06:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 06:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 07:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 07:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 08:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 08:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 09:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 09:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 10:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 10:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 11:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 11:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 12:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 12:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 13:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 13:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 14:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 14:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 15:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 15:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 16:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 16:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 17:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 17:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 18:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 18:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 19:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 19:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 20:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 20:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 21:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 21:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 22:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 22:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-26 23:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-26 23:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 00:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 00:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 01:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 01:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 02:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 02:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 03:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 03:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 04:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 04:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 05:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 05:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 06:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 06:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 07:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 07:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 08:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 08:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 09:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 09:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 10:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 10:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 11:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 11:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 12:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 12:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 13:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 13:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 14:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 14:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 15:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 15:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 16:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 16:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 17:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 17:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 18:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 18:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 19:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 19:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 20:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 20:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 21:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 21:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 22:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 22:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-27 23:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-27 23:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 00:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 00:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 01:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 01:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 02:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 02:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 03:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 03:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 04:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 04:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 05:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 05:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 06:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 06:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 07:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 07:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 08:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 08:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 09:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 09:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 10:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 10:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 11:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 11:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 12:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 12:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 13:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 13:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 14:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 14:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 15:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 15:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 16:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 16:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 17:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 17:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 18:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 18:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 19:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 19:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 20:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 20:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 21:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 21:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 22:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 22:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-28 23:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-28 23:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 00:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 00:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 01:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 01:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 02:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 02:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 03:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 03:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 04:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 04:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 05:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 05:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 06:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 06:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 07:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 07:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 08:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 08:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 09:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 09:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 10:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 10:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 11:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 11:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 12:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 12:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 13:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 13:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 14:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 14:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 15:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 15:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 16:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 16:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 17:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 17:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 18:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 18:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 19:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 19:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 20:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 20:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 21:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 21:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 22:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 22:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-29 23:00:00\n", - "week: 51\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-29 23:00:00+01:00') week: 51 stage: st0 duration: 0\n", - "date: 2030-12-30 00:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 00:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 01:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 01:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 02:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 02:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 03:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 03:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 04:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 04:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 05:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 05:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 06:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 06:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 07:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 07:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 08:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 08:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 09:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 09:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 10:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 10:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 11:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 11:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 12:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 12:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 13:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 13:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 14:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 14:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 15:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 15:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 16:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 16:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 17:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 17:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 18:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 18:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 19:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 19:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 20:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 20:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 21:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 21:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 22:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 22:00:00+01:00') week: 0 stage: st0 duration: 0\n", - "date: 2030-12-30 23:00:00\n", - "week: 0\n", - "0\n", - "extreme: 0\n", - "loadlevel: (2030, 'TF', '12-30 23:00:00+01:00') week: 0 stage: st0 duration: 0\n" - ] - } - ], - "source": [ - "dfDuration['Duration'] *= 0\n", - "for i in list_idx:\n", - " _date = pd.to_datetime(str(i[0])+'-'+i[2][:14], format='%Y-%m-%d %H:%M:%S', errors='coerce')\n", - " print('date: ', _date)\n", - " _week = _date.isocalendar().week - 1 + 52*(int(unique_values.index(i[0])))\n", - " print('week: ', _week)\n", - " # redefining the column stage\n", - " dfDuration.loc[i, 'Stage'] = 'st'+str(a[_week])\n", - " print(int(dfDuration.loc[i, 'Stage'][2:len(dfDuration.loc[i, 'Stage'])]))\n", - " if int(dfDuration.loc[i, 'Stage'][2:]) in extreme_periods_centers:\n", - " print('extreme: ', 1)\n", - " dfDuration.loc[i, 'Duration'] = 1\n", - " else:\n", - " print('extreme: ', 0)\n", - " if _week in typical_periods_centers:\n", - " dfDuration.loc[i, 'Duration'] = 1\n", - " print('loadlevel: ', i, 'week: ', _week, 'stage: ', dfDuration.loc[i, 'Stage'], 'duration: ', dfDuration.loc[i, 'Duration'])" - ] - }, - { - "cell_type": "code", - "execution_count": 473, - "id": "2ee2d43f", - "metadata": {}, - "outputs": [], - "source": [ - "# dfDuration.to_csv(_path+'/oT_Data_Duration_' +CaseName+'_ByStages'+'.csv')\n", - "dfDuration.to_csv(os.path.join(CaseName + '_ByStages', 'oT_Data_Duration_' + CaseName + '_ByStages' + '.csv'))" - ] - }, - { - "cell_type": "code", - "execution_count": 474, - "id": "a072e580", - "metadata": {}, - "outputs": [], - "source": [ - "dfStages = pd.read_csv(os.path.join(CaseName, 'oT_Data_Stage_' + CaseName + '.csv'), index_col=[0])" - ] - }, - { - "cell_type": "code", - "execution_count": 475, - "id": "8239dabd", - "metadata": {}, - "outputs": [], - "source": [ - "NoOccur = pd.Series(aggregation.clusterPeriodNoOccur)" - ] - }, - { - "cell_type": "code", - "execution_count": 476, - "id": "c06c5230", - "metadata": {}, - "outputs": [], - "source": [ - "# remove all rows from dfStages\n", - "dfStages = dfStages.iloc[0:0]\n", - "for i in stages:\n", - " dfStages.loc['st'+str(i), 'Weight'] = NoOccur[i]" - ] - }, - { - "cell_type": "code", - "execution_count": 477, - "id": "0b2658d3", - "metadata": {}, - "outputs": [], - "source": [ - "dfStages.to_csv(os.path.join(CaseName + '_ByStages', 'oT_Data_Stage_' + CaseName + '_ByStages' + '.csv'))" - ] - }, - { - "cell_type": "code", - "execution_count": 478, - "id": "1bfe4566", - "metadata": {}, - "outputs": [], - "source": [ - "# dictStages = pd.read_csv(os.path.join(DirName, CaseName + '_ByStages', 'oT_Dict_Stage_' + CaseName + '_ByStages' + '.csv'), index_col=[0])" - ] - }, - { - "cell_type": "code", - "execution_count": 479, - "id": "8c4ba8c1", - "metadata": {}, - "outputs": [], - "source": [ - "dictStages = pd.DataFrame(['st'+str(i) for i in stages], columns=['Stage'])" - ] - }, - { - "cell_type": "code", - "execution_count": 480, - "id": "195f8842", - "metadata": {}, - "outputs": [], - "source": [ - "dictStages.to_csv(os.path.join(CaseName + '_ByStages', 'oT_Dict_Stage_' + CaseName + '_ByStages' + '.csv'), index=False)" + "active = int((dur[\"Duration\"] > 0).sum())\n", + "print(f\"active hours: {active} of {len(dur)} ({active / len(dur):.0%} of the year)\")\n", + "untouched = pd.read_csv(f\"{CaseName}/oT_Data_Duration_{CaseName}.csv\")[\"Duration\"].sum()\n", + "print(f\"committed 9n still has all {int(untouched)} hours active (unchanged)\")" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -142653,7 +690,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.2" + "version": "3.12.13" } }, "nbformat": 4, From 2927831d0713fd79c0346c7bc7f781ea3e3b1ce5 Mon Sep 17 00:00:00 2001 From: Erik Alvarez Date: Mon, 29 Jun 2026 22:39:43 +0200 Subject: [PATCH 2/2] Drop raw-profiles subplot from 3.1 to shrink the notebook Removes the full-year subplot (the duration-curve and occurrence charts already show the data); 3.1 goes from ~224 KB to ~80 KB. --- notebooks/3.1-LoadLevelAggregation_TSAM.ipynb | 70 +++++-------------- 1 file changed, 16 insertions(+), 54 deletions(-) diff --git a/notebooks/3.1-LoadLevelAggregation_TSAM.ipynb b/notebooks/3.1-LoadLevelAggregation_TSAM.ipynb index fa261a0..5b5dfd3 100644 --- a/notebooks/3.1-LoadLevelAggregation_TSAM.ipynb +++ b/notebooks/3.1-LoadLevelAggregation_TSAM.ipynb @@ -7,7 +7,7 @@ "source": [ "# Time-series aggregation with TSAM\n", "\n", - "A full year at hourly resolution is 8 760 time steps. For a large planning model that is expensive to solve. **Time-series aggregation** shrinks the year to a few *representative periods* — for example a handful of typical weeks — while keeping the shape of demand and renewable supply. openTEPES can then solve on those representative periods and weight each by how often it occurs.\n", + "A full year at hourly resolution is 8 760 time steps. For a large planning model that is expensive to solve. **Time-series aggregation** shrinks the year to a few *representative periods* \u2014 for example a handful of typical weeks \u2014 while keeping the shape of demand and renewable supply. openTEPES can then solve on those representative periods and weight each by how often it occurs.\n", "\n", "This notebook uses [TSAM](https://github.com/FZJ-IEK3-VSA/tsam) (the Time Series Aggregation Module) to turn the 9n year into **four typical weeks**, and writes the stage files openTEPES reads.\n", "\n", @@ -185,44 +185,6 @@ "profiles.head()" ] }, - { - "cell_type": "markdown", - "id": "dd8492da", - "metadata": {}, - "source": [ - "The full year, one line per series:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "95512caa", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-29T20:33:40.635277Z", - "iopub.status.busy": "2026-06-29T20:33:40.635221Z", - "iopub.status.idle": "2026-06-29T20:33:41.249537Z", - "shell.execute_reply": "2026-06-29T20:33:41.249097Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "profiles.plot(subplots=True, figsize=(9, 6))\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, { "cell_type": "markdown", "id": "75988d3c", @@ -239,7 +201,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "6cf1e4f4", "metadata": { "execution": { @@ -352,7 +314,7 @@ " 4 5445.518133 159.954635 0.57 2463.157424" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -383,7 +345,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "e827d4ce", "metadata": { "execution": { @@ -419,7 +381,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "6d3cc327", "metadata": { "execution": { @@ -465,7 +427,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "1fe93f6e", "metadata": { "execution": { @@ -513,16 +475,16 @@ "\n", "openTEPES drives a stage-based run from three files:\n", "\n", - "- `oT_Data_Stage` — each stage and its weight (how many weeks it stands for),\n", - "- `oT_Dict_Stage` — the list of stage names,\n", - "- `oT_Data_Duration` — for each hour, which stage it belongs to and whether it is active.\n", + "- `oT_Data_Stage` \u2014 each stage and its weight (how many weeks it stands for),\n", + "- `oT_Dict_Stage` \u2014 the list of stage names,\n", + "- `oT_Data_Duration` \u2014 for each hour, which stage it belongs to and whether it is active.\n", "\n", - "The weeks are contiguous and 168 hours long, so the week of hour *i* is simply `i // 168`. `clusterOrder` tells us which representative each week maps to, and `clusterCenterIndices` are the representative weeks themselves — only those hours stay active (duration 1); the rest collapse to 0 and are stood in for by their representative." + "The weeks are contiguous and 168 hours long, so the week of hour *i* is simply `i // 168`. `clusterOrder` tells us which representative each week maps to, and `clusterCenterIndices` are the representative weeks themselves \u2014 only those hours stay active (duration 1); the rest collapse to 0 and are stood in for by their representative." ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "42b419e1", "metadata": { "execution": { @@ -598,7 +560,7 @@ "3 st3 18" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -639,14 +601,14 @@ "source": [ "## What we got\n", "\n", - "From a full hourly year we produced four typical weeks and the stage files openTEPES needs to run on them. The active hours dropped from 8 736 to 4 × 168 = 672, a large saving, while the duration curve still follows the original.\n", + "From a full hourly year we produced four typical weeks and the stage files openTEPES needs to run on them. The active hours dropped from 8 736 to 4 \u00d7 168 = 672, a large saving, while the duration curve still follows the original.\n", "\n", - "Everything was written under `work_TSAM/`, so the committed `9n` case is unchanged. To solve the aggregated case you would point openTEPES at the `9n_ByStages` folder — see [03-Stages](03-Stages.ipynb) for how stages are used in a run." + "Everything was written under `work_TSAM/`, so the committed `9n` case is unchanged. To solve the aggregated case you would point openTEPES at the `9n_ByStages` folder \u2014 see [03-Stages](03-Stages.ipynb) for how stages are used in a run." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "45c4d3b8", "metadata": { "execution": { @@ -695,4 +657,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file